// ORG   $0000
                   // FCC   "g GCE 1983"
                   // FCB   $80
                   // FDB   L19D1
                   // FCB   $F8, $40                ; h,w of raster image
                   // FCB   $18, $C4                ; y,x of raster image
                   // FCC   "POLAR RESCUE"
                   // FCB   $80
                   // FCB   $00
  case 0x001F:                                       mon("L001F    JSR   DP_to_C8                ; 001F: BD F1 AF      \n");
    memory[--S] = 0x0022 & 0xff; memory[--S] = 0x0022 >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x0022:                                       mon("L0022    DEC   <$24                    ; 0022: 0A 24         \n");
    res = (UINT8)(memory_DP[0x24] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x24] & ~res;
    memory_DP[0x24] = res;
                                                     mon("         CLR   <$21                    ; 0024: 0F 21         \n");
    memory_DP[0x21] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$22                    ; 0026: 0F 22         \n");
    memory_DP[0x22] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   #$0205                  ; 0028: CC 02 05      \n");
    A = (UINT8)((0x0205) >> 8);
    B = (UINT8)((0x0205) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Select_Game             ; 002B: BD F7 A9      \n");
    memory[--S] = 0x002e & 0xff; memory[--S] = 0x002e >> 8;
    PC = 0xf7a9;
    JUMP;
  case 0x002E:                                       mon("L002E    DEC   <$79                    ; 002E: 0A 79         \n");
    res = (UINT8)(memory_DP[0x79] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x79] & ~res;
    memory_DP[0x79] = res;
                                                     mon("         DEC   <$7A                    ; 0030: 0A 7A         \n");
    res = (UINT8)(memory_DP[0x7a] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x7a] & ~res;
    memory_DP[0x7a] = res;
  case 0x0032:                                       mon("L0032    LDX   #$C880                  ; 0032: 8E C8 80      \n");
    X = 0xc880;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$0368                  ; 0035: CC 03 68      \n");
    A = (UINT8)((0x0368) >> 8);
    B = (UINT8)((0x0368) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Clear_x_d               ; 0038: BD F5 48      \n");
    memory[--S] = 0x003b & 0xff; memory[--S] = 0x003b >> 8;
    PC = 0xf548;
    JUMP;
  case 0x003B:                                       mon("L003B    LDA   <$7A                    ; 003B: 96 7A         \n");
    A = (UINT8)memory_DP[0x7a];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$F1                    ; 003D: 97 F1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xf1] = A;
                                                     mon("         LDD   #$B0                    ; 003F: CC 00 B0      \n");
    A = (UINT8)((0x00b0) >> 8);
    B = (UINT8)((0x00b0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$3D                    ; 0042: DD 3D         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x3d] = A;
    memory_DP[0x3d + 1] = B;
                                                     mon("         JSR   $0FF9                   ; 0044: BD 0F F9      \n");
    memory[--S] = 0x0047 & 0xff; memory[--S] = 0x0047 >> 8;
    PC = 0x0ff9;
    JUMP;
  case 0x0047:                                       mon("L0047    LDA   #$05                    ; 0047: 86 05         \n");
    A = (UINT8)(SINT8)0x05;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$E4                    ; 0049: 97 E4         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xe4] = A;
                                                     mon("         LDB   <$79                    ; 004B: D6 79         \n");
    B = (UINT8)memory_DP[0x79];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $51                     ; 004D: 27 02         \n");
    if (!Z) {
    PC = 0x0051;
    JUMP;
    }
                                                     mon("         STA   <$E5                    ; 004F: 97 E5         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xe5] = A;
  case 0x0051:                                       mon("L0051    LDD   #$0BB8                  ; 0051: CC 0B B8      \n");
    A = (UINT8)((0x0bb8) >> 8);
    B = (UINT8)((0x0bb8) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$E2                    ; 0054: DD E2         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xe2] = A;
    memory_DP[0xe2 + 1] = B;
                                                     mon("         LDX   #$CA53                  ; 0056: 8E CA 53      \n");
    X = 0xca53;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$7FA0                  ; 0059: CC 7F A0      \n");
    A = (UINT8)((0x7fa0) >> 8);
    B = (UINT8)((0x7fa0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   -2,X                    ; 005C: ED 1E         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(X + 0xfffe)] = A;
    memory[(UINT16)(X + 0xfffe) + 1] = B;
                                                     mon("         LDB   #$34                    ; 005E: C6 34         \n");
    B = (UINT8)(SINT8)0x34;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STD   $07,X                   ; 0060: ED 07         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(X + 0x0007)] = A;
    memory[(UINT16)(X + 0x0007) + 1] = B;
                                                     mon("         JSR   Clear_Score             ; 0062: BD F8 4F      \n");
    memory[--S] = 0x0065 & 0xff; memory[--S] = 0x0065 >> 8;
    PC = 0xf84f;
    JUMP;
  case 0x0065:                                       mon("L0065    LEAX  $09,X                   ; 0065: 30 09         \n");
    X = (X + 0x0009);
 // Z = X;
                                                     mon("         JSR   Clear_Score             ; 0067: BD F8 4F      \n");
    memory[--S] = 0x006a & 0xff; memory[--S] = 0x006a >> 8;
    PC = 0xf84f;
    JUMP;
  case 0x006A:                                       mon("L006A    JSR   DP_to_C8                ; 006A: BD F1 AF      \n");
    memory[--S] = 0x006d & 0xff; memory[--S] = 0x006d >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x006D:                                       mon("L006D    LDX   #$C880                  ; 006D: 8E C8 80      \n");
    X = 0xc880;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$5D                    ; 0070: CC 00 5D      \n");
    A = (UINT8)((0x005d) >> 8);
    B = (UINT8)((0x005d) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Clear_x_d               ; 0073: BD F5 48      \n");
    memory[--S] = 0x0076 & 0xff; memory[--S] = 0x0076 >> 8;
    PC = 0xf548;
    JUMP;
  case 0x0076:                                       mon("L0076    LDU   #$1FD3                  ; 0076: CE 1F D3      \n");
    U = 0x1fd3;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   #$09                    ; 0079: 86 09         \n");
    A = (UINT8)(SINT8)0x09;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$F1                    ; 007B: D6 F1         \n");
    B = (UINT8)memory_DP[0xf1];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 007D: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         LEAU  D,U                     ; 007E: 33 CB         \n");
    U = (U + (((UINT8)A<<8)|(UINT8)B));
                                                     mon("         LDX   #$C8F3                  ; 0080: 8E C8 F3      \n");
    X = 0xc8f3;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDA   #$09                    ; 0083: 86 09         \n");
    A = (UINT8)(SINT8)0x09;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Move_Mem_a              ; 0085: BD F6 83      \n");
    memory[--S] = 0x0088 & 0xff; memory[--S] = 0x0088 >> 8;
    PC = 0xf683;
    JUMP;
  case 0x0088:                                       mon("L0088    JSR   $0B50                   ; 0088: BD 0B 50      \n");
    memory[--S] = 0x008b & 0xff; memory[--S] = 0x008b >> 8;
    PC = 0x0b50;
    JUMP;
  case 0x008B:                                       mon("L008B    LDA   #$04                    ; 008B: 86 04         \n");
    A = (UINT8)(SINT8)0x04;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$C3                    ; 008D: 97 C3         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc3] = A;
                                                     mon("         JSR   $10B9                   ; 008F: BD 10 B9      \n");
    memory[--S] = 0x0092 & 0xff; memory[--S] = 0x0092 >> 8;
    PC = 0x10b9;
    JUMP;
  case 0x0092:                                       mon("L0092    JSR   $0AFD                   ; 0092: BD 0A FD      \n");
    memory[--S] = 0x0095 & 0xff; memory[--S] = 0x0095 >> 8;
    PC = 0x0afd;
    JUMP;
  case 0x0095:                                       mon("L0095    LDA   <$FB                    ; 0095: 96 FB         \n");
    A = (UINT8)memory_DP[0xfb];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$C1                    ; 0097: 97 C1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc1] = A;
  case 0x0099:                                       mon("L0099    LDX   #$C891                  ; 0099: 8E C8 91      \n");
    X = 0xc891;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #$C880                  ; 009C: CE C8 80      \n");
    U = 0xc880;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         CLRA                          ; 009F: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         STA   <$CE                    ; 00A0: 97 CE         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xce] = A;
                                                     mon("         STA   <$BD                    ; 00A2: 97 BD         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xbd] = A;
                                                     mon("         JSR   $0F2E                   ; 00A4: BD 0F 2E      \n");
    memory[--S] = 0x00a7 & 0xff; memory[--S] = 0x00a7 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x00A7:                                       mon("L00A7    LDA   #$03                    ; 00A7: 86 03         \n");
    A = (UINT8)(SINT8)0x03;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x00A9:                                       mon("L00A9    STA   <$9E                    ; 00A9: 97 9E         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9e] = A;
                                                     mon("         CMPA  #$02                    ; 00AB: 81 02         \n");
    res = A - (SINT8)0x02;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x02) & (A ^ (UINT8)res);
                                                     mon("         BNE   $B3                     ; 00AD: 26 04         \n");
    if (Z) {
    PC = 0x00b3;
    JUMP;
    }
                                                     mon("         CLRA                          ; 00AF: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 00B0: 5F            \n");
    B = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         BRA   $DA                     ; 00B1: 20 27         \n");
    PC = 0x00da;
    JUMP;
    
  case 0x00B3:                                       mon("L00B3    JSR   Random                  ; 00B3: BD F5 17      \n");
    memory[--S] = 0x00b6 & 0xff; memory[--S] = 0x00b6 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x00B6:                                       mon("L00B6    TFR   CC,B                    ; 00B6: 1F A9         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    B = CC;
                                                     mon("         STB   <$A0                    ; 00B8: D7 A0         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xa0] = B;
                                                     mon("         JSR   $10F6                   ; 00BA: BD 10 F6      \n");
    memory[--S] = 0x00bd & 0xff; memory[--S] = 0x00bd >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x00BD:                                       mon("L00BD    TSTA                          ; 00BD: 4D            \n");
 // Z = A;
    N = A;
 // V = 0;
                                                     mon("         BPL   $C3                     ; 00BE: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x00c3;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 00C0: BD 19 CB      \n");
    memory[--S] = 0x00c3 & 0xff; memory[--S] = 0x00c3 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x00C3:                                       mon("L00C3    CMPD  <$F5                    ; 00C3: 10 93 F5      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xf5]<<8)|memory_DP[0xf5 + 1]));
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xf5]<<8)|memory_DP[0xf5 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BCS   $B3                     ; 00C6: 25 EB         \n");
    if (C) {
    PC = 0x00b3;
    JUMP;
    }
                                                     mon("         CMPD  <$F7                    ; 00C8: 10 93 F7      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xf7]<<8)|memory_DP[0xf7 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xf7]<<8)|memory_DP[0xf7 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BHI   $B3                     ; 00CB: 22 E6         \n");
    if (Z && (!C)) {
    PC = 0x00b3;
    JUMP;
    }
                                                     mon("         PSHS  A                       ; 00CD: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   <$A0                    ; 00CF: 96 A0         \n");
    A = (UINT8)memory_DP[0xa0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,CC                    ; 00D1: 1F 8A         \n");
    CC = A;
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         PULS  A                       ; 00D3: 35 02         \n");
    A = memory[S++];
                                                     mon("         BPL   $DA                     ; 00D5: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x00da;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 00D7: BD 19 CB      \n");
    memory[--S] = 0x00da & 0xff; memory[--S] = 0x00da >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x00DA:                                       mon("L00DA    STD   ,X++                    ; 00DA: ED 81         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[X] = A;
    memory[X + 1] = B;
    X = X + 2;
                                                     mon("         CLR   ,U+                     ; 00DC: 6F C0         \n");
    memory[U] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
    U = U + 1;
                                                     mon("         CLR   ,U+                     ; 00DE: 6F C0         \n");
    memory[U] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
    U = U + 1;
                                                     mon("         LDA   <$9E                    ; 00E0: 96 9E         \n");
    A = (UINT8)memory_DP[0x9e];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         DECA                          ; 00E2: 4A            \n");
    res = (UINT8)(A - 1);
 // N = res;
    Z = res;
 // V = A & ~res;
    A = res;
                                                     mon("         BNE   $A9                     ; 00E3: 26 C4         \n");
    if (Z) {
    PC = 0x00a9;
    JUMP;
    }
                                                     mon("         LDA   #$07                    ; 00E5: 86 07         \n");
    A = (UINT8)(SINT8)0x07;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$9E                    ; 00E7: 97 9E         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9e] = A;
                                                     mon("         LDU   #$C9F0                  ; 00E9: CE C9 F0      \n");
    U = 0xc9f0;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
  case 0x00EC:                                       mon("L00EC    JSR   $10F6                   ; 00EC: BD 10 F6      \n");
    memory[--S] = 0x00ef & 0xff; memory[--S] = 0x00ef >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x00EF:                                       mon("L00EF    ASRB                          ; 00EF: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 00F0: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 00F1: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 00F2: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 00F3: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ADDB  <$86                    ; 00F4: DB 86         \n");
    res = B + memory_DP[0x86];
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ memory_DP[0x86] ^ (UINT8)res ^ C;
 // V = B ^ memory_DP[0x86] ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         ADDB  #$20                    ; 00F6: CB 20         \n");
    res = B + (SINT8)0x20;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         ANDB  #$3F                    ; 00F8: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         LDA   #$7F                    ; 00FA: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Rise_Run_Y              ; 00FC: BD F6 01      \n");
    memory[--S] = 0x00ff & 0xff; memory[--S] = 0x00ff >> 8;
    PC = 0xf601;
    JUMP;
  case 0x00FF:                                       mon("L00FF    STA   <$97                    ; 00FF: 97 97         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
                                                     mon("         ASRB                          ; 0101: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         SEX                           ; 0102: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$84                    ; 0103: D3 84         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x84]<<8)|memory_DP[0x84 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 0105: ED 44         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         LDB   <$97                    ; 0107: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ASRB                          ; 0109: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         SEX                           ; 010A: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$80                    ; 010B: D3 80         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x80]<<8)|memory_DP[0x80 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 010D: ED 40         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         JSR   $10F6                   ; 010F: BD 10 F6      \n");
    memory[--S] = 0x0112 & 0xff; memory[--S] = 0x0112 >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x0112:                                       mon("L0112    ASRB                          ; 0112: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 0113: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 0114: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 0115: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         SEX                           ; 0116: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$82                    ; 0117: D3 82         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x82]<<8)|memory_DP[0x82 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 0119: ED 42         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
                                                     mon("         LEAU  $08,U                   ; 011B: 33 48         \n");
    U = (U + 0x0008);
                                                     mon("         DEC   <$9E                    ; 011D: 0A 9E         \n");
    res = (UINT8)(memory_DP[0x9e] - 1);
 // N = res;
    Z = res;
 // V = memory_DP[0x9e] & ~res;
    memory_DP[0x9e] = res;
                                                     mon("         BNE   $EC                     ; 011F: 26 CB         \n");
    if (Z) {
    PC = 0x00ec;
    JUMP;
    }
                                                     mon("         CLRA                          ; 0121: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         STA   <$CC                    ; 0122: 97 CC         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xcc] = A;
                                                     mon("         DECA                          ; 0124: 4A            \n");
    res = (UINT8)(A - 1);
 // N = res;
 // Z = res;
 // V = A & ~res;
    A = res;
                                                     mon("         STA   <$EB                    ; 0125: 97 EB         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xeb] = A;
  case 0x0127:                                       mon("L0127    JSR   DP_to_C8                ; 0127: BD F1 AF      \n");
    memory[--S] = 0x012a & 0xff; memory[--S] = 0x012a >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x012A:                                       mon("L012A    LDA   <$11                    ; 012A: 96 11         \n");
    A = (UINT8)memory_DP[0x11];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $013F                   ; 012C: 27 11         \n");
    if (!Z) {
    PC = 0x013f;
    JUMP;
    }
                                                     mon("         JSR   Random                  ; 012E: BD F5 17      \n");
    memory[--S] = 0x0131 & 0xff; memory[--S] = 0x0131 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0131:                                       mon("L0131    LDB   #$02                    ; 0131: C6 02         \n");
    B = (UINT8)(SINT8)0x02;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 0133: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 0134: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         LDX   <$7B                    ; 0136: 9E 7B         \n");
    X = ((memory_DP[0x7b]<<8)|memory_DP[0x7b + 1]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   <$11                    ; 0138: D6 11         \n");
    B = (UINT8)memory_DP[0x11];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STB   A,X                     ; 013A: E7 86         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(X + (SINT8)A)] = B;
                                                     mon("         JSR   Random_3                ; 013C: BD F5 11      \n");
    memory[--S] = 0x013f & 0xff; memory[--S] = 0x013f >> 8;
    PC = 0xf511;
    JUMP;
  case 0x013F:                                       mon("L013F    JSR   Init_Music_chk          ; 013F: BD F6 87      \n");
    memory[--S] = 0x0142 & 0xff; memory[--S] = 0x0142 >> 8;
    PC = 0xf687;
    JUMP;
  case 0x0142:                                       mon("L0142    JSR   Explosion_Snd           ; 0142: BD F9 2E      \n");
    memory[--S] = 0x0145 & 0xff; memory[--S] = 0x0145 >> 8;
    PC = 0xf92e;
    JUMP;
  case 0x0145:                                       mon("L0145    LDA   <$CC                    ; 0145: 96 CC         \n");
    A = (UINT8)memory_DP[0xcc];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0155                   ; 0147: 26 0C         \n");
    if (Z) {
    PC = 0x0155;
    JUMP;
    }
                                                     mon("         LDA   <$0F                    ; 0149: 96 0F         \n");
    A = (UINT8)memory_DP[0x0f];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0151                   ; 014B: 26 04         \n");
    if (Z) {
    PC = 0x0151;
    JUMP;
    }
                                                     mon("         DEC   <$CC                    ; 014D: 0A CC         \n");
    res = (UINT8)(memory_DP[0xcc] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xcc] & ~res;
    memory_DP[0xcc] = res;
                                                     mon("         BRA   $0155                   ; 014F: 20 04         \n");
    PC = 0x0155;
    JUMP;
    
  case 0x0151:                                       mon("L0151    CLR   <$11                    ; 0151: 0F 11         \n");
    memory_DP[0x11] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$0F                    ; 0153: 0F 0F         \n");
    memory_DP[0x0f] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
  case 0x0155:                                       mon("L0155    LDD   <$C5                    ; 0155: DC C5         \n");
    A = memory_DP[0xc5];
    B = memory_DP[0xc5 + 1];
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         LBEQ  $0249                   ; 0157: 10 27 00 EE   \n");
    if (!Z) {
    PC = 0x0249;
    JUMP;
    }
                                                     mon("         JSR   $0B34                   ; 015B: BD 0B 34      \n");
    memory[--S] = 0x015e & 0xff; memory[--S] = 0x015e >> 8;
    PC = 0x0b34;
    JUMP;
  case 0x015E:                                       mon("L015E    BCS   $018B                   ; 015E: 25 2B         \n");
    if (C) {
    PC = 0x018b;
    JUMP;
    }
                                                     mon("         TSTB                          ; 0160: 5D            \n");
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BEQ   $0179                   ; 0161: 27 16         \n");
    if (!Z) {
    PC = 0x0179;
    JUMP;
    }
                                                     mon("         SUBA  #$02                    ; 0163: 80 02         \n");
    res = A - (SINT8)0x02;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x02) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BCC   $0189                   ; 0165: 24 22         \n");
    if (!C) {
    PC = 0x0189;
    JUMP;
    }
                                                     mon("         LDD   #$5000                  ; 0167: CC 50 00      \n");
    A = (UINT8)((0x5000) >> 8);
    B = (UINT8)((0x5000) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12CF                   ; 016A: BD 12 CF      \n");
    memory[--S] = 0x016d & 0xff; memory[--S] = 0x016d >> 8;
    PC = 0x12cf;
    JUMP;
  case 0x016D:                                       mon("L016D    LDA   <$F1                    ; 016D: 96 F1         \n");
    A = (UINT8)memory_DP[0xf1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$04                    ; 016F: 81 04         \n");
    res = A - (SINT8)0x04;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x04) & (A ^ (UINT8)res);
                                                     mon("         BCC   $0174                   ; 0171: 24 01         \n");
    if (!C) {
    PC = 0x0174;
    JUMP;
    }
                                                     mon("         INCA                          ; 0173: 4C            \n");
    res = (UINT8)(A + 1);
 // Z = res;
 // N = res;
 // V = res & ~(A);
    A = res;
  case 0x0174:                                       mon("L0174    STA   <$F1                    ; 0174: 97 F1         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0xf1] = A;
                                                     mon("         JMP   $6A                     ; 0176: 7E 00 6A      \n");
    PC = 0x006a;
    JUMP;
    
  case 0x0179:                                       mon("L0179    CMPA  #$E0                    ; 0179: 81 E0         \n");
    res = A - (SINT8)0xe0;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0xe0) & (A ^ (UINT8)res);
                                                     mon("         BCS   $0187                   ; 017B: 25 0A         \n");
    if (C) {
    PC = 0x0187;
    JUMP;
    }
                                                     mon("         LDA   <$D9                    ; 017D: 96 D9         \n");
    A = (UINT8)memory_DP[0xd9];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $018B                   ; 017F: 26 0A         \n");
    if (Z) {
    PC = 0x018b;
    JUMP;
    }
                                                     mon("         LDA   #$3F                    ; 0181: 86 3F         \n");
    A = (UINT8)(SINT8)0x3f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$D9                    ; 0183: 97 D9         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0xd9] = A;
                                                     mon("         BRA   $018B                   ; 0185: 20 04         \n");
    PC = 0x018b;
    JUMP;
    
  case 0x0187:                                       mon("L0187    ADDA  #$02                    ; 0187: 8B 02         \n");
    res = A + (SINT8)0x02;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x02 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x02 ^ (UINT8)res ^ C;
    A = (UINT8)res;
  case 0x0189:                                       mon("L0189    STA   <$C5                    ; 0189: 97 C5         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc5] = A;
  case 0x018B:                                       mon("L018B    CLR   <$B9                    ; 018B: 0F B9         \n");
    memory_DP[0xb9] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$B8                    ; 018D: 0F B8         \n");
    memory_DP[0xb8] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDA   <$C5                    ; 018F: 96 C5         \n");
    A = (UINT8)memory_DP[0xc5];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$EB                    ; 0191: 97 EB         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xeb] = A;
                                                     mon("         CMPA  #$C0                    ; 0193: 81 C0         \n");
    res = A - (SINT8)0xc0;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0xc0) & (A ^ (UINT8)res);
                                                     mon("         BCS   $0199                   ; 0195: 25 02         \n");
    if (C) {
    PC = 0x0199;
    JUMP;
    }
                                                     mon("         LDA   #$C0                    ; 0197: 86 C0         \n");
    A = (UINT8)(SINT8)0xc0;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x0199:                                       mon("L0199    LSRA                          ; 0199: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 019A: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 019B: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 019C: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 019D: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LDB   #$06                    ; 019E: C6 06         \n");
    B = (UINT8)(SINT8)0x06;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDU   #$CA6D                  ; 01A0: CE CA 6D      \n");
    U = 0xca6d;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         CLR   <$97                    ; 01A3: 0F 97         \n");
    memory_DP[0x97] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x01A5:                                       mon("L01A5    PSHS  DP,B,A                  ; 01A5: 34 0E         \n");
    memory[--S] = (DP >> 8);
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDA   B,U                     ; 01A7: A6 C5         \n");
    A = (UINT8)memory[(UINT16)(U + (SINT8)B)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TST   <$D2                    ; 01A9: 0D D2         \n");
    Z = memory_DP[0xd2];
 // N = memory_DP[0xd2];
 // V = 0;
                                                     mon("         BNE   $01C2                   ; 01AB: 26 15         \n");
    if (Z) {
    PC = 0x01c2;
    JUMP;
    }
                                                     mon("         TST   <$C6                    ; 01AD: 0D C6         \n");
    Z = memory_DP[0xc6];
 // N = memory_DP[0xc6];
 // V = 0;
                                                     mon("         BNE   $01B5                   ; 01AF: 26 04         \n");
    if (Z) {
    PC = 0x01b5;
    JUMP;
    }
                                                     mon("         SUBA  ,S                      ; 01B1: A0 E4         \n");
    res = A - memory[S];
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BRA   $01B7                   ; 01B3: 20 02         \n");
    PC = 0x01b7;
    JUMP;
    
  case 0x01B5:                                       mon("L01B5    ADDA  ,S                      ; 01B5: AB E4         \n");
    res = A + memory[S];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
    N = (UINT8)res;
    H = A ^ memory[S] ^ (UINT8)res ^ C;
 // V = A ^ memory[S] ^ (UINT8)res ^ C;
    A = (UINT8)res;
  case 0x01B7:                                       mon("L01B7    BPL   $01C2                   ; 01B7: 2A 09         \n");
    if ((SINT8)N >= 0) {
    PC = 0x01c2;
    JUMP;
    }
                                                     mon("         LDB   <$C5                    ; 01B9: D6 C5         \n");
    B = (UINT8)memory_DP[0xc5];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         CMPB  #$E0                    ; 01BB: C1 E0         \n");
    res = B - (SINT8)0xe0;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0xe0) & (B ^ (UINT8)res);
                                                     mon("         BCS   $01C0                   ; 01BD: 25 01         \n");
    if (C) {
    PC = 0x01c0;
    JUMP;
    }
                                                     mon("         CLRA                          ; 01BF: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x01C0:                                       mon("L01C0    ANDA  #$7F                    ; 01C0: 84 7F         \n");
    A = A & (SINT8)0x7f;
 // Z = A;
 // N = A;
 // V = 0;
  case 0x01C2:                                       mon("L01C2    PSHS  A                       ; 01C2: 34 02         \n");
    memory[--S] = A;
                                                     mon("         ORA   <$97                    ; 01C4: 9A 97         \n");
    A = A | memory_DP[0x97];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$97                    ; 01C6: 97 97         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
                                                     mon("         PULS  A                       ; 01C8: 35 02         \n");
    A = memory[S++];
                                                     mon("         LDB   $01,S                   ; 01CA: E6 61         \n");
    B = (UINT8)memory[(UINT16)(S + 0x0001)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STA   B,U                     ; 01CC: A7 C5         \n");
    Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + (SINT8)B)] = A;
                                                     mon("         BEQ   $01F0                   ; 01CE: 27 20         \n");
    if (!Z) {
    PC = 0x01f0;
    JUMP;
    }
                                                     mon("         STA   <$B7                    ; 01D0: 97 B7         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xb7] = A;
                                                     mon("         JSR   $1320                   ; 01D2: BD 13 20      \n");
    memory[--S] = 0x01d5 & 0xff; memory[--S] = 0x01d5 >> 8;
    PC = 0x1320;
    JUMP;
  case 0x01D5:                                       mon("L01D5    JSR   DP_to_D0                ; 01D5: BD F1 AA      \n");
    memory[--S] = 0x01d8 & 0xff; memory[--S] = 0x01d8 >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x01D8:                                       mon("L01D8    LDD   $C8BB                   ; 01D8: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 01DB: BD F2 FC      \n");
    memory[--S] = 0x01de & 0xff; memory[--S] = 0x01de >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x01DE:                                       mon("L01DE    LDA   #$7F                    ; 01DE: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8BA                   ; 01E0: B0 C8 BA      \n");
    res = A - memory[0xc8ba];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[0xc8ba]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         STA   <$06                    ; 01E3: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         JSR   Intensity_a             ; 01E5: BD F2 AB      \n");
    memory[--S] = 0x01e8 & 0xff; memory[--S] = 0x01e8 >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x01E8:                                       mon("L01E8    LDX   #$1B5F                  ; 01E8: 8E 1B 5F      \n");
    X = 0x1b5f;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         ASL   <$06                    ; 01EB: 08 06         \n");
    res = memory_DP[0x06] << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = memory_DP[0x06] ^ res;
    memory_DP[0x06] = res;
                                                     mon("         JSR   Mov_Draw_VLc_a          ; 01ED: BD F3 AD      \n");
    memory[--S] = 0x01f0 & 0xff; memory[--S] = 0x01f0 >> 8;
    PC = 0xf3ad;
    JUMP;
  case 0x01F0:                                       mon("L01F0    PULS  A,B,DP                  ; 01F0: 35 0E         \n");
    A = memory[S++];
    B = memory[S++];
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         DECB                          ; 01F2: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         BPL   $01A5                   ; 01F3: 2A B0         \n");
    if ((SINT8)N >= 0) {
    PC = 0x01a5;
    JUMP;
    }
                                                     mon("         PSHS  DP                      ; 01F5: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_D0                ; 01F7: BD F1 AA      \n");
    memory[--S] = 0x01fa & 0xff; memory[--S] = 0x01fa >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x01FA:                                       mon("L01FA    LDA   $C8C5                   ; 01FA: B6 C8 C5      \n");
    A = (UINT8)memory[0xc8c5];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LSRA                          ; 01FD: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         PSHS  A                       ; 01FE: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   #$7F                    ; 0200: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 0202: A0 E0         \n");
    res = A - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         JSR   Intensity_a             ; 0204: BD F2 AB      \n");
    memory[--S] = 0x0207 & 0xff; memory[--S] = 0x0207 >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x0207:                                       mon("L0207    LDU   #$1A58                  ; 0207: CE 1A 58      \n");
    U = 0x1a58;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1021                   ; 020A: BD 10 21      \n");
    memory[--S] = 0x020d & 0xff; memory[--S] = 0x020d >> 8;
    PC = 0x1021;
    JUMP;
  case 0x020D:                                       mon("L020D    PULS  DP                      ; 020D: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDA   <$97                    ; 020F: 96 97         \n");
    A = (UINT8)memory_DP[0x97];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0215                   ; 0211: 26 02         \n");
    if (Z) {
    PC = 0x0215;
    JUMP;
    }
                                                     mon("         STA   <$C5                    ; 0213: 97 C5         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc5] = A;
  case 0x0215:                                       mon("L0215    LDA   <$D2                    ; 0215: 96 D2         \n");
    A = (UINT8)memory_DP[0xd2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0246                   ; 0217: 26 2D         \n");
    if (Z) {
    PC = 0x0246;
    JUMP;
    }
                                                     mon("         LDD   <$ED                    ; 0219: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         TST   <$C7                    ; 021B: 0D C7         \n");
    Z = memory_DP[0xc7];
 // N = memory_DP[0xc7];
 // V = 0;
                                                     mon("         BEQ   $0228                   ; 021D: 27 09         \n");
    if (!Z) {
    PC = 0x0228;
    JUMP;
    }
                                                     mon("         ADDD  #$12                    ; 021F: C3 00 12      \n");
    arg = (A << 8) | B;
    res = arg + 0x0012;
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0012) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         BCC   $0234                   ; 0222: 24 10         \n");
    if (!C) {
    PC = 0x0234;
    JUMP;
    }
                                                     mon("         CLRA                          ; 0224: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 0225: 5F            \n");
    B = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         BRA   $0234                   ; 0226: 20 0C         \n");
    PC = 0x0234;
    JUMP;
    
  case 0x0228:                                       mon("L0228    ADDD  #$14                    ; 0228: C3 00 14      \n");
    arg = (A << 8) | B;
    res = arg + 0x0014;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0014) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$07FF                  ; 022B: 10 83 07 FF   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x07ff);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x07ff)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLE   $0234                   ; 022F: 2F 03         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x0234;
    JUMP;
    }
                                                     mon("         LDD   #$07FF                  ; 0231: CC 07 FF      \n");
    A = (UINT8)((0x07ff) >> 8);
    B = (UINT8)((0x07ff) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x0234:                                       mon("L0234    STD   <$ED                    ; 0234: DD ED         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xed] = A;
    memory_DP[0xed + 1] = B;
                                                     mon("         LDA   <$C6                    ; 0236: 96 C6         \n");
    A = (UINT8)memory_DP[0xc6];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0246                   ; 0238: 26 0C         \n");
    if (Z) {
    PC = 0x0246;
    JUMP;
    }
                                                     mon("         LDD   <$EF                    ; 023A: DC EF         \n");
    A = memory_DP[0xef];
    B = memory_DP[0xef + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ADDD  #$02AA                  ; 023C: C3 02 AA      \n");
    arg = (A << 8) | B;
    res = arg + 0x02aa;
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x02aa) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         BCC   $0244                   ; 023F: 24 03         \n");
    if (!C) {
    PC = 0x0244;
    JUMP;
    }
                                                     mon("         LDD   #$FFFF                  ; 0241: CC FF FF      \n");
    A = (UINT8)((0xffff) >> 8);
    B = (UINT8)((0xffff) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x0244:                                       mon("L0244    STD   <$EF                    ; 0244: DD EF         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0xef] = A;
    memory_DP[0xef + 1] = B;
  case 0x0246:                                       mon("L0246    JMP   $089F                   ; 0246: 7E 08 9F      \n");
    PC = 0x089f;
    JUMP;
    
  case 0x0249:                                       mon("L0249    LDA   <$D2                    ; 0249: 96 D2         \n");
    A = (UINT8)memory_DP[0xd2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0289                   ; 024B: 26 3C         \n");
    if (Z) {
    PC = 0x0289;
    JUMP;
    }
                                                     mon("         LDA   <$C7                    ; 024D: 96 C7         \n");
    A = (UINT8)memory_DP[0xc7];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0289                   ; 024F: 27 38         \n");
    if (!Z) {
    PC = 0x0289;
    JUMP;
    }
                                                     mon("         LDA   <$C8                    ; 0251: 96 C8         \n");
    A = (UINT8)memory_DP[0xc8];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0265                   ; 0253: 26 10         \n");
    if (Z) {
    PC = 0x0265;
    JUMP;
    }
                                                     mon("         CLRA                          ; 0255: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 0256: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         STD   <$ED                    ; 0257: DD ED         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xed] = A;
    memory_DP[0xed + 1] = B;
                                                     mon("         STD   <$8A                    ; 0259: DD 8A         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x8a] = A;
    memory_DP[0x8a + 1] = B;
                                                     mon("         INC   <$C7                    ; 025B: 0C C7         \n");
    res = (UINT8)(memory_DP[0xc7] + 1);
    Z = res;
 // N = res;
 // V = res & ~(memory_DP[0xc7]);
    memory_DP[0xc7] = res;
                                                     mon("         BNE   $0289                   ; 025D: 26 2A         \n");
    if (Z) {
    PC = 0x0289;
    JUMP;
    }
                                                     mon("         INC   <$C8                    ; 025F: 0C C8         \n");
    res = (UINT8)(memory_DP[0xc8] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0xc8]);
    memory_DP[0xc8] = res;
                                                     mon("         DEC   <$C7                    ; 0261: 0A C7         \n");
    res = (UINT8)(memory_DP[0xc7] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xc7] & ~res;
    memory_DP[0xc7] = res;
                                                     mon("         BRA   $0289                   ; 0263: 20 24         \n");
    PC = 0x0289;
    JUMP;
    
  case 0x0265:                                       mon("L0265    DEC   <$C7                    ; 0265: 0A C7         \n");
    res = (UINT8)(memory_DP[0xc7] - 1);
 // N = res;
    Z = res;
 // V = memory_DP[0xc7] & ~res;
    memory_DP[0xc7] = res;
                                                     mon("         BNE   $0289                   ; 0267: 26 20         \n");
    if (Z) {
    PC = 0x0289;
    JUMP;
    }
                                                     mon("         LDA   <$C8                    ; 0269: 96 C8         \n");
    A = (UINT8)memory_DP[0xc8];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BMI   $0278                   ; 026B: 2B 0B         \n");
    if ((SINT8)N <  0) {
    PC = 0x0278;
    JUMP;
    }
                                                     mon("         DEC   <$C7                    ; 026D: 0A C7         \n");
    res = (UINT8)(memory_DP[0xc7] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xc7] & ~res;
    memory_DP[0xc7] = res;
                                                     mon("         NEG   <$C8                    ; 026F: 00 C8         \n");
 // V = (UINT8)(-memory_DP[0xc8]) & (memory_DP[0xc8]);
    C = (-memory_DP[0xc8]) & 0x100;
    memory_DP[0xc8] = (UINT8)(-memory_DP[0xc8]);
 // Z = memory_DP[0xc8];
 // N = memory_DP[0xc8];
                                                     mon("         LDD   #$F900                  ; 0271: CC F9 00      \n");
    A = (UINT8)((0xf900) >> 8);
    B = (UINT8)((0xf900) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$8A                    ; 0274: DD 8A         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0x8a] = A;
    memory_DP[0x8a + 1] = B;
                                                     mon("         BRA   $0289                   ; 0276: 20 11         \n");
    PC = 0x0289;
    JUMP;
    
  case 0x0278:                                       mon("L0278    CLRA                          ; 0278: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 0279: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         STD   <$C7                    ; 027A: DD C7         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xc7] = A;
    memory_DP[0xc7 + 1] = B;
                                                     mon("         STD   <$8A                    ; 027C: DD 8A         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x8a] = A;
    memory_DP[0x8a + 1] = B;
                                                     mon("         LDD   #$E0FF                  ; 027E: CC E0 FF      \n");
    A = (UINT8)((0xe0ff) >> 8);
    B = (UINT8)((0xe0ff) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$C5                    ; 0281: DD C5         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0xc5] = A;
    memory_DP[0xc5 + 1] = B;
                                                     mon("         JSR   $0B55                   ; 0283: BD 0B 55      \n");
    memory[--S] = 0x0286 & 0xff; memory[--S] = 0x0286 >> 8;
    PC = 0x0b55;
    JUMP;
  case 0x0286:                                       mon("L0286    JMP   $089F                   ; 0286: 7E 08 9F      \n");
    PC = 0x089f;
    JUMP;
    
  case 0x0289:                                       mon("L0289    LDA   <$D0                    ; 0289: 96 D0         \n");
    A = (UINT8)memory_DP[0xd0];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         LBNE  $04AA                   ; 028B: 10 26 02 1B   \n");
    if (Z) {
    PC = 0x04aa;
    JUMP;
    }
                                                     mon("         LDA   <$EC                    ; 028F: 96 EC         \n");
    A = (UINT8)memory_DP[0xec];
    N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $02BC                   ; 0291: 27 29         \n");
    if (!Z) {
    PC = 0x02bc;
    JUMP;
    }
                                                     mon("         BPL   $02A9                   ; 0293: 2A 14         \n");
    if ((SINT8)N >= 0) {
    PC = 0x02a9;
    JUMP;
    }
                                                     mon("         LDX   #$CA53                  ; 0295: 8E CA 53      \n");
    X = 0xca53;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #Vec_High_Score         ; 0298: CE CB EB      \n");
    U = 0xcbeb;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   New_High_Score          ; 029B: BD F8 D8      \n");
    memory[--S] = 0x029e & 0xff; memory[--S] = 0x029e >> 8;
    PC = 0xf8d8;
    JUMP;
  case 0x029E:                                       mon("L029E    LDX   #$CA5C                  ; 029E: 8E CA 5C      \n");
    X = 0xca5c;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #Vec_High_Score         ; 02A1: CE CB EB      \n");
    U = 0xcbeb;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   New_High_Score          ; 02A4: BD F8 D8      \n");
    memory[--S] = 0x02a7 & 0xff; memory[--S] = 0x02a7 >> 8;
    PC = 0xf8d8;
    JUMP;
  case 0x02A7:                                       mon("L02A7    NEG   <$EC                    ; 02A7: 00 EC         \n");
 // V = (UINT8)(-memory_DP[0xec]) & (memory_DP[0xec]);
    C = (-memory_DP[0xec]) & 0x100;
    memory_DP[0xec] = (UINT8)(-memory_DP[0xec]);
 // Z = memory_DP[0xec];
 // N = memory_DP[0xec];
  case 0x02A9:                                       mon("L02A9    LDX   <$E2                    ; 02A9: 9E E2         \n");
    X = ((memory_DP[0xe2]<<8)|memory_DP[0xe2 + 1]);
 // Z = X;
    N = (X) >> 8;
    V = 0;
                                                     mon("         LEAX  -1,X                    ; 02AB: 30 1F         \n");
    X = (X + 0xffff);
    Z = X;
                                                     mon("         LBEQ  Cold_Start              ; 02AD: 10 27 ED 4F   \n");
    if (!Z) {
    PC = 0xf000;
    JUMP;
    }
                                                     mon("         STX   <$E2                    ; 02B1: 9F E2         \n");
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
    memory_DP[0xe2] = (UINT8)((X) >> 8);
    memory_DP[(UINT16)(0xe2 + 1)] = (X) & 0xff;
                                                     mon("         LDA   <$11                    ; 02B3: 96 11         \n");
    A = (UINT8)memory_DP[0x11];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         LBNE  $32                     ; 02B5: 10 26 FD 79   \n");
    if (Z) {
    PC = 0x0032;
    JUMP;
    }
  case 0x02B9:                                       mon("L02B9    JMP   $0643                   ; 02B9: 7E 06 43      \n");
    PC = 0x0643;
    JUMP;
    
  case 0x02BC:                                       mon("L02BC    JSR   $0B34                   ; 02BC: BD 0B 34      \n");
    memory[--S] = 0x02bf & 0xff; memory[--S] = 0x02bf >> 8;
    PC = 0x0b34;
    JUMP;
  case 0x02BF:                                       mon("L02BF    BCS   $02B9                   ; 02BF: 25 F8         \n");
    if (C) {
    PC = 0x02b9;
    JUMP;
    }
                                                     mon("         LDA   <$C0                    ; 02C1: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$80                    ; 02C3: 81 80         \n");
    res = A - (SINT8)0x80;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x80) & (A ^ (UINT8)res);
                                                     mon("         BCC   $02D3                   ; 02C5: 24 0C         \n");
    if (!C) {
    PC = 0x02d3;
    JUMP;
    }
                                                     mon("         LDA   <$C7                    ; 02C7: 96 C7         \n");
    A = (UINT8)memory_DP[0xc7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$CE                    ; 02C9: 9A CE         \n");
    A = A | memory_DP[0xce];
    Z = A;
    N = A;
    V = 0;
                                                     mon("         LBNE  $039B                   ; 02CB: 10 26 00 CC   \n");
    if (Z) {
    PC = 0x039b;
    JUMP;
    }
                                                     mon("         LDA   <$BE                    ; 02CF: 96 BE         \n");
    A = (UINT8)memory_DP[0xbe];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $02D7                   ; 02D1: 27 04         \n");
    if (!Z) {
    PC = 0x02d7;
    JUMP;
    }
  case 0x02D3:                                       mon("L02D3    CLRA                          ; 02D3: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 02D4: 5F            \n");
    B = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         BRA   $02E2                   ; 02D5: 20 0B         \n");
    PC = 0x02e2;
    JUMP;
    
  case 0x02D7:                                       mon("L02D7    LDA   <$BD                    ; 02D7: 96 BD         \n");
    A = (UINT8)memory_DP[0xbd];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $02E0                   ; 02D9: 2A 05         \n");
    if ((SINT8)N >= 0) {
    PC = 0x02e0;
    JUMP;
    }
                                                     mon("         LDD   #$0130                  ; 02DB: CC 01 30      \n");
    A = (UINT8)((0x0130) >> 8);
    B = (UINT8)((0x0130) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         BRA   $02E2                   ; 02DE: 20 02         \n");
    PC = 0x02e2;
    JUMP;
    
  case 0x02E0:                                       mon("L02E0    LDD   <$F3                    ; 02E0: DC F3         \n");
    A = memory_DP[0xf3];
    B = memory_DP[0xf3 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x02E2:                                       mon("L02E2    STD   <$8A                    ; 02E2: DD 8A         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x8a] = A;
    memory_DP[0x8a + 1] = B;
                                                     mon("         LDB   <$11                    ; 02E4: D6 11         \n");
    B = (UINT8)memory_DP[0x11];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BITB  #$08                    ; 02E6: C5 08         \n");
    res = B & (SINT8)0x08;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $02F8                   ; 02E8: 26 0E         \n");
    if (Z) {
    PC = 0x02f8;
    JUMP;
    }
                                                     mon("         LDA   <$CB                    ; 02EA: 96 CB         \n");
    A = (UINT8)memory_DP[0xcb];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $02F2                   ; 02EC: 27 04         \n");
    if (!Z) {
    PC = 0x02f2;
    JUMP;
    }
                                                     mon("         DEC   <$CB                    ; 02EE: 0A CB         \n");
    res = (UINT8)(memory_DP[0xcb] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xcb] & ~res;
    memory_DP[0xcb] = res;
                                                     mon("         BRA   $0360                   ; 02F0: 20 6E         \n");
    PC = 0x0360;
    JUMP;
    
  case 0x02F2:                                       mon("L02F2    LDB   <$0F                    ; 02F2: D6 0F         \n");
    B = (UINT8)memory_DP[0x0f];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BITB  #$08                    ; 02F4: C5 08         \n");
    res = B & (SINT8)0x08;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0360                   ; 02F6: 27 68         \n");
    if (!Z) {
    PC = 0x0360;
    JUMP;
    }
  case 0x02F8:                                       mon("L02F8    LDA   #$14                    ; 02F8: 86 14         \n");
    A = (UINT8)(SINT8)0x14;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$CB                    ; 02FA: 97 CB         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xcb] = A;
                                                     mon("         LDA   <$C1                    ; 02FC: 96 C1         \n");
    A = (UINT8)memory_DP[0xc1];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0360                   ; 02FE: 27 60         \n");
    if (!Z) {
    PC = 0x0360;
    JUMP;
    }
                                                     mon("         LDB   <$90                    ; 0300: D6 90         \n");
    B = (UINT8)memory_DP[0x90];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         INCB                          ; 0302: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
                                                     mon("         ANDB  #$03                    ; 0303: C4 03         \n");
    B = B & (SINT8)0x03;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   <$90                    ; 0305: D7 90         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x90] = B;
                                                     mon("         LDA   <$C0                    ; 0307: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$10                    ; 0309: 81 10         \n");
    res = A - (SINT8)0x10;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x10) & (A ^ (UINT8)res);
                                                     mon("         BCS   $0316                   ; 030B: 25 09         \n");
    if (C) {
    PC = 0x0316;
    JUMP;
    }
                                                     mon("         LSRA                          ; 030D: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 030E: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 030F: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 0310: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         DECA                          ; 0311: 4A            \n");
    res = (UINT8)(A - 1);
 // N = res;
 // Z = res;
 // V = A & ~res;
    A = res;
                                                     mon("         CMPA  <$90                    ; 0312: 91 90         \n");
    res = A - memory_DP[0x90];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ memory_DP[0x90]) & (A ^ (UINT8)res);
                                                     mon("         BCC   $0360                   ; 0314: 24 4A         \n");
    if (!C) {
    PC = 0x0360;
    JUMP;
    }
  case 0x0316:                                       mon("L0316    LDA   #$00                    ; 0316: 86 00         \n");
    A = (UINT8)(SINT8)0x00;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $1149                   ; 0318: BD 11 49      \n");
    memory[--S] = 0x031b & 0xff; memory[--S] = 0x031b >> 8;
    PC = 0x1149;
    JUMP;
  case 0x031B:                                       mon("L031B    BCS   $0360                   ; 031B: 25 43         \n");
    if (C) {
    PC = 0x0360;
    JUMP;
    }
                                                     mon("         LDA   <$C1                    ; 031D: 96 C1         \n");
    A = (UINT8)memory_DP[0xc1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0B1E                   ; 031F: BD 0B 1E      \n");
    memory[--S] = 0x0322 & 0xff; memory[--S] = 0x0322 >> 8;
    PC = 0x0b1e;
    JUMP;
  case 0x0322:                                       mon("L0322    STA   <$C1                    ; 0322: 97 C1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc1] = A;
                                                     mon("         LDA   #$0F                    ; 0324: 86 0F         \n");
    A = (UINT8)(SINT8)0x0f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$D7                    ; 0326: 97 D7         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xd7] = A;
                                                     mon("         LDB   <$90                    ; 0328: D6 90         \n");
    B = (UINT8)memory_DP[0x90];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STB   $06,U                   ; 032A: E7 46         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x0006)] = B;
                                                     mon("         LDX   #$1C93                  ; 032C: 8E 1C 93      \n");
    X = 0x1c93;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         ASLB                          ; 032F: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ABX                           ; 0330: 3A            \n");
    X = X + B;
                                                     mon("         LDA   <$ED                    ; 0331: 96 ED         \n");
    A = (UINT8)memory_DP[0xed];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $0336                   ; 0333: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0336;
    JUMP;
    }
                                                     mon("         CLRA                          ; 0335: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0336:                                       mon("L0336    ADDA  #$04                    ; 0336: 8B 04         \n");
    res = A + (SINT8)0x04;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x04 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x04 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         LDB   <$86                    ; 0338: D6 86         \n");
    B = (UINT8)memory_DP[0x86];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ADDB  #$20                    ; 033A: CB 20         \n");
    res = B + (SINT8)0x20;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         JSR   Rise_Run_Y              ; 033C: BD F6 01      \n");
    memory[--S] = 0x033f & 0xff; memory[--S] = 0x033f >> 8;
    PC = 0xf601;
    JUMP;
  case 0x033F:                                       mon("L033F    STD   $08,U                   ; 033F: ED 48         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0008)] = A;
    memory[(UINT16)(U + 0x0008) + 1] = B;
                                                     mon("         LDA   $01,X                   ; 0341: A6 01         \n");
    A = (UINT8)memory[(UINT16)(X + 0x0001)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Rise_a            ; 0343: BD F6 61      \n");
    memory[--S] = 0x0346 & 0xff; memory[--S] = 0x0346 >> 8;
    PC = 0xf661;
    JUMP;
  case 0x0346:                                       mon("L0346    TFR   A,B                     ; 0346: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 0348: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$84                    ; 0349: D3 84         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x84]<<8)|memory_DP[0x84 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 034B: ED 44         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         LDA   $01,X                   ; 034D: A6 01         \n");
    A = (UINT8)memory[(UINT16)(X + 0x0001)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Run_a             ; 034F: BD F6 5B      \n");
    memory[--S] = 0x0352 & 0xff; memory[--S] = 0x0352 >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x0352:                                       mon("L0352    TFR   A,B                     ; 0352: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 0354: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$80                    ; 0355: D3 80         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x80]<<8)|memory_DP[0x80 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 0357: ED 40         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         LDB   ,X                      ; 0359: E6 84         \n");
    B = (UINT8)memory[X];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 035B: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$82                    ; 035C: D3 82         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x82]<<8)|memory_DP[0x82 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 035E: ED 42         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
  case 0x0360:                                       mon("L0360    LDD   <$ED                    ; 0360: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CMPD  #$0700                  ; 0362: 10 83 07 00   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0700);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0700)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $036D                   ; 0366: 2D 05         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x036d;
    JUMP;
    }
                                                     mon("         SUBD  #$40                    ; 0368: 83 00 40      \n");
    arg = (A << 8) | B;
    res = arg - (0x0040);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    V = ((arg ^ (0x0040)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BRA   $03B8                   ; 036B: 20 4B         \n");
    PC = 0x03b8;
    JUMP;
    
  case 0x036D:                                       mon("L036D    LDA   <$C0                    ; 036D: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$70                    ; 036F: 81 70         \n");
    res = A - (SINT8)0x70;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x70) & (A ^ (UINT8)res);
                                                     mon("         BCC   $039B                   ; 0371: 24 28         \n");
    if (!C) {
    PC = 0x039b;
    JUMP;
    }
                                                     mon("         LDA   <$0F                    ; 0373: 96 0F         \n");
    A = (UINT8)memory_DP[0x0f];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$06                    ; 0375: 84 06         \n");
    A = A & (SINT8)0x06;
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $039B                   ; 0377: 27 22         \n");
    if (!Z) {
    PC = 0x039b;
    JUMP;
    }
                                                     mon("         CMPA  #$06                    ; 0379: 81 06         \n");
    res = A - (SINT8)0x06;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x06) & (A ^ (UINT8)res);
                                                     mon("         BEQ   $03C2                   ; 037B: 27 45         \n");
    if (!Z) {
    PC = 0x03c2;
    JUMP;
    }
                                                     mon("         BITA  #$04                    ; 037D: 85 04         \n");
    res = A & (SINT8)0x04;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $038E                   ; 037F: 27 0D         \n");
    if (!Z) {
    PC = 0x038e;
    JUMP;
    }
                                                     mon("         LDD   <$ED                    ; 0381: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ADDD  #$20                    ; 0383: C3 00 20      \n");
    arg = (A << 8) | B;
    res = arg + 0x0020;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0020) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$0700                  ; 0386: 10 83 07 00   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0700);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0700)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $03C2                   ; 038A: 2E 36         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x03c2;
    JUMP;
    }
                                                     mon("         BRA   $03B8                   ; 038C: 20 2A         \n");
    PC = 0x03b8;
    JUMP;
    
  case 0x038E:                                       mon("L038E    LDD   <$ED                    ; 038E: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  #$20                    ; 0390: 83 00 20      \n");
    arg = (A << 8) | B;
    res = arg - (0x0020);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x0020)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$F900                  ; 0393: 10 83 F9 00   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xf900);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xf900)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $03C2                   ; 0397: 2D 29         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x03c2;
    JUMP;
    }
                                                     mon("         BRA   $03B8                   ; 0399: 20 1D         \n");
    PC = 0x03b8;
    JUMP;
    
  case 0x039B:                                       mon("L039B    LDD   <$ED                    ; 039B: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CMPD  <$8A                    ; 039D: 10 93 8A      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BEQ   $03B8                   ; 03A0: 27 16         \n");
    if (!Z) {
    PC = 0x03b8;
    JUMP;
    }
                                                     mon("         BGT   $03AE                   ; 03A2: 2E 0A         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x03ae;
    JUMP;
    }
                                                     mon("         ADDD  #$0A                    ; 03A4: C3 00 0A      \n");
    arg = (A << 8) | B;
    res = arg + 0x000a;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x000a) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  <$8A                    ; 03A7: 10 93 8A      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $03B6                   ; 03AA: 2E 0A         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x03b6;
    JUMP;
    }
                                                     mon("         BRA   $03B8                   ; 03AC: 20 0A         \n");
    PC = 0x03b8;
    JUMP;
    
  case 0x03AE:                                       mon("L03AE    SUBD  #$0A                    ; 03AE: 83 00 0A      \n");
    arg = (A << 8) | B;
    res = arg - (0x000a);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x000a)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  <$8A                    ; 03B1: 10 93 8A      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x8a]<<8)|memory_DP[0x8a + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $03B8                   ; 03B4: 2E 02         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x03b8;
    JUMP;
    }
  case 0x03B6:                                       mon("L03B6    LDD   <$8A                    ; 03B6: DC 8A         \n");
    A = memory_DP[0x8a];
    B = memory_DP[0x8a + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x03B8:                                       mon("L03B8    STD   <$ED                    ; 03B8: DD ED         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xed] = A;
    memory_DP[0xed + 1] = B;
                                                     mon("         LDA   <$C7                    ; 03BA: 96 C7         \n");
    A = (UINT8)memory_DP[0xc7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$CE                    ; 03BC: 9A CE         \n");
    A = A | memory_DP[0xce];
    Z = A;
    N = A;
    V = 0;
                                                     mon("         LBNE  $0403                   ; 03BE: 10 26 00 41   \n");
    if (Z) {
    PC = 0x0403;
    JUMP;
    }
  case 0x03C2:                                       mon("L03C2    LDB   <$CE                    ; 03C2: D6 CE         \n");
    B = (UINT8)memory_DP[0xce];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BNE   $03DC                   ; 03C4: 26 16         \n");
    if (Z) {
    PC = 0x03dc;
    JUMP;
    }
                                                     mon("         LDB   <$26                    ; 03C6: D6 26         \n");
    B = (UINT8)memory_DP[0x26];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BITB  #$03                    ; 03C8: C5 03         \n");
    res = B & (SINT8)0x03;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $03DC                   ; 03CA: 26 10         \n");
    if (Z) {
    PC = 0x03dc;
    JUMP;
    }
                                                     mon("         LDB   <$86                    ; 03CC: D6 86         \n");
    B = (UINT8)memory_DP[0x86];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   <$1B                    ; 03CE: 96 1B         \n");
    A = (UINT8)memory_DP[0x1b];
    N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $03DC                   ; 03D0: 27 0A         \n");
    if (!Z) {
    PC = 0x03dc;
    JUMP;
    }
                                                     mon("         BMI   $03D7                   ; 03D2: 2B 03         \n");
    if ((SINT8)N <  0) {
    PC = 0x03d7;
    JUMP;
    }
                                                     mon("         DECB                          ; 03D4: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
    Z = res;
    V = B & ~res;
    B = res;
                                                     mon("         BRA   $03D8                   ; 03D5: 20 01         \n");
    PC = 0x03d8;
    JUMP;
    
  case 0x03D7:                                       mon("L03D7    INCB                          ; 03D7: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
  case 0x03D8:                                       mon("L03D8    ANDB  #$3F                    ; 03D8: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   <$86                    ; 03DA: D7 86         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x86] = B;
  case 0x03DC:                                       mon("L03DC    TST   <$1C                    ; 03DC: 0D 1C         \n");
    Z = memory_DP[0x1c];
    N = memory_DP[0x1c];
 // V = 0;
                                                     mon("         BEQ   $0403                   ; 03DE: 27 23         \n");
    if (!Z) {
    PC = 0x0403;
    JUMP;
    }
                                                     mon("         BMI   $03E7                   ; 03E0: 2B 05         \n");
    if ((SINT8)N <  0) {
    PC = 0x03e7;
    JUMP;
    }
                                                     mon("         LDD   #$FF40                  ; 03E2: CC FF 40      \n");
    A = (UINT8)((0xff40) >> 8);
    B = (UINT8)((0xff40) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         BRA   $03EA                   ; 03E5: 20 03         \n");
    PC = 0x03ea;
    JUMP;
    
  case 0x03E7:                                       mon("L03E7    LDD   #$C0                    ; 03E7: CC 00 C0      \n");
    A = (UINT8)((0x00c0) >> 8);
    B = (UINT8)((0x00c0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x03EA:                                       mon("L03EA    STD   <$97                    ; 03EA: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDA   <$88                    ; 03EC: 96 88         \n");
    A = (UINT8)memory_DP[0x88];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ADDA  <$98                    ; 03EE: 9B 98         \n");
    res = A + memory_DP[0x98];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory_DP[0x98] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0x98] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         STA   <$99                    ; 03F0: 97 99         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x99] = A;
                                                     mon("         LDB   <$97                    ; 03F2: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 03F4: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         STD   <$97                    ; 03F5: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDD   <$82                    ; 03F7: DC 82         \n");
    A = memory_DP[0x82];
    B = memory_DP[0x82 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ADCB  <$98                    ; 03F9: D9 98         \n");
    res = B + memory_DP[0x98] + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ memory_DP[0x98] ^ (UINT8)res ^ C;
 // V = B ^ memory_DP[0x98] ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         ADCA  <$97                    ; 03FB: 99 97         \n");
    res = A + memory_DP[0x97] + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory_DP[0x97] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0x97] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         STD   <$82                    ; 03FD: DD 82         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x82] = A;
    memory_DP[0x82 + 1] = B;
                                                     mon("         LDA   <$99                    ; 03FF: 96 99         \n");
    A = (UINT8)memory_DP[0x99];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$88                    ; 0401: 97 88         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x88] = A;
  case 0x0403:                                       mon("L0403    LDD   <$ED                    ; 0403: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ASRA                          ; 0405: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0406: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 0407: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0408: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 0409: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 040A: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 040B: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 040C: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         TFR   B,A                     ; 040D: 1F 98         \n");
    A = B;
                                                     mon("         LDB   <$86                    ; 040F: D6 86         \n");
    B = (UINT8)memory_DP[0x86];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ADDB  #$20                    ; 0411: CB 20         \n");
    res = B + (SINT8)0x20;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         JSR   Rise_Run_Y              ; 0413: BD F6 01      \n");
    memory[--S] = 0x0416 & 0xff; memory[--S] = 0x0416 >> 8;
    PC = 0xf601;
    JUMP;
  case 0x0416:                                       mon("L0416    STA   <$97                    ; 0416: 97 97         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
                                                     mon("         SEX                           ; 0418: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ASLB                          ; 0419: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 041A: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 041B: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 041C: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 041D: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 041E: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         STD   <$8E                    ; 041F: DD 8E         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x8e] = A;
    memory_DP[0x8e + 1] = B;
                                                     mon("         LDB   <$89                    ; 0421: D6 89         \n");
    B = (UINT8)memory_DP[0x89];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   <$85                    ; 0423: 96 85         \n");
    A = (UINT8)memory_DP[0x85];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ADDD  <$8E                    ; 0425: D3 8E         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x8e]<<8)|memory_DP[0x8e + 1]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x8e]<<8)|memory_DP[0x8e + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   <$89                    ; 0427: D7 89         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x89] = B;
                                                     mon("         STA   <$85                    ; 0429: 97 85         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x85] = A;
                                                     mon("         LDB   <$8E                    ; 042B: D6 8E         \n");
    B = (UINT8)memory_DP[0x8e];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 042D: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADCA  <$84                    ; 042E: 99 84         \n");
    res = A + memory_DP[0x84] + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory_DP[0x84] ^ (UINT8)res ^ C;
    V = A ^ memory_DP[0x84] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         BVS   $0434                   ; 0430: 29 02         \n");
    if ((SINT8)V <  0) {
    PC = 0x0434;
    JUMP;
    }
                                                     mon("         STA   <$84                    ; 0432: 97 84         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x84] = A;
  case 0x0434:                                       mon("L0434    LDB   <$97                    ; 0434: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0436: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ASLB                          ; 0437: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 0438: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 0439: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 043A: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 043B: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 043C: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         STD   <$8C                    ; 043D: DD 8C         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x8c] = A;
    memory_DP[0x8c + 1] = B;
                                                     mon("         LDB   <$87                    ; 043F: D6 87         \n");
    B = (UINT8)memory_DP[0x87];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   <$81                    ; 0441: 96 81         \n");
    A = (UINT8)memory_DP[0x81];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ADDD  <$8C                    ; 0443: D3 8C         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x8c]<<8)|memory_DP[0x8c + 1]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x8c]<<8)|memory_DP[0x8c + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   <$87                    ; 0445: D7 87         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x87] = B;
                                                     mon("         STA   <$81                    ; 0447: 97 81         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x81] = A;
                                                     mon("         LDB   <$8C                    ; 0449: D6 8C         \n");
    B = (UINT8)memory_DP[0x8c];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 044B: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADCA  <$80                    ; 044C: 99 80         \n");
    res = A + memory_DP[0x80] + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory_DP[0x80] ^ (UINT8)res ^ C;
    V = A ^ memory_DP[0x80] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         BVS   $0452                   ; 044E: 29 02         \n");
    if ((SINT8)V <  0) {
    PC = 0x0452;
    JUMP;
    }
                                                     mon("         STA   <$80                    ; 0450: 97 80         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x80] = A;
  case 0x0452:                                       mon("L0452    LDD   <$C7                    ; 0452: DC C7         \n");
    A = memory_DP[0xc7];
    B = memory_DP[0xc7 + 1];
    Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         BNE   $047E                   ; 0454: 26 28         \n");
    if (Z) {
    PC = 0x047e;
    JUMP;
    }
                                                     mon("         LDA   <$C0                    ; 0456: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0471                   ; 0458: 27 17         \n");
    if (!Z) {
    PC = 0x0471;
    JUMP;
    }
                                                     mon("         CMPA  #$99                    ; 045A: 81 99         \n");
    res = A - (SINT8)0x99;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x99) & (A ^ (UINT8)res);
                                                     mon("         BCS   $0466                   ; 045C: 25 08         \n");
    if (C) {
    PC = 0x0466;
    JUMP;
    }
                                                     mon("         CLR   <$56                    ; 045E: 0F 56         \n");
    memory_DP[0x56] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         DEC   <$D3                    ; 0460: 0A D3         \n");
    res = (UINT8)(memory_DP[0xd3] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd3] & ~res;
    memory_DP[0xd3] = res;
                                                     mon("         INC   $0D,U                   ; 0462: 6C 4D         \n");
    res = (UINT8)(memory[(UINT16)(U + 0x000d)] + 1);
    Z = res;
    N = res;
    V = res & ~(memory[(UINT16)(U + 0x000d)]);
    memory[(UINT16)(U + 0x000d)] = res;
                                                     mon("         BRA   $0490                   ; 0464: 20 2A         \n");
    PC = 0x0490;
    JUMP;
    
  case 0x0466:                                       mon("L0466    LDB   <$26                    ; 0466: D6 26         \n");
    B = (UINT8)memory_DP[0x26];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BITB  #$1F                    ; 0468: C5 1F         \n");
    res = B & (SINT8)0x1f;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $0471                   ; 046A: 26 05         \n");
    if (Z) {
    PC = 0x0471;
    JUMP;
    }
                                                     mon("         JSR   $0B1E                   ; 046C: BD 0B 1E      \n");
    memory[--S] = 0x046f & 0xff; memory[--S] = 0x046f >> 8;
    PC = 0x0b1e;
    JUMP;
  case 0x046F:                                       mon("L046F    STA   <$C0                    ; 046F: 97 C0         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc0] = A;
  case 0x0471:                                       mon("L0471    LDA   <$D0                    ; 0471: 96 D0         \n");
    A = (UINT8)memory_DP[0xd0];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $04AA                   ; 0473: 26 35         \n");
    if (Z) {
    PC = 0x04aa;
    JUMP;
    }
                                                     mon("         LDD   <$EF                    ; 0475: DC EF         \n");
    A = memory_DP[0xef];
    B = memory_DP[0xef + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  #$14                    ; 0477: 83 00 14      \n");
    arg = (A << 8) | B;
    res = arg - (0x0014);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x0014)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BCS   $0481                   ; 047A: 25 05         \n");
    if (C) {
    PC = 0x0481;
    JUMP;
    }
                                                     mon("         STD   <$EF                    ; 047C: DD EF         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0xef] = A;
    memory_DP[0xef + 1] = B;
  case 0x047E:                                       mon("L047E    JMP   $05AE                   ; 047E: 7E 05 AE      \n");
    PC = 0x05ae;
    JUMP;
    
  case 0x0481:                                       mon("L0481    CLRA                          ; 0481: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 0482: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         STD   <$EF                    ; 0483: DD EF         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xef] = A;
    memory_DP[0xef + 1] = B;
                                                     mon("         JSR   $0F2E                   ; 0485: BD 0F 2E      \n");
    memory[--S] = 0x0488 & 0xff; memory[--S] = 0x0488 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0488:                                       mon("L0488    DEC   <$D1                    ; 0488: 0A D1         \n");
    res = (UINT8)(memory_DP[0xd1] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd1] & ~res;
    memory_DP[0xd1] = res;
                                                     mon("         LDU   #$1A0F                  ; 048A: CE 1A 0F      \n");
    U = 0x1a0f;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   Init_Music              ; 048D: BD F6 8D      \n");
    memory[--S] = 0x0490 & 0xff; memory[--S] = 0x0490 >> 8;
    PC = 0xf68d;
    JUMP;
  case 0x0490:                                       mon("L0490    LDB   #$4D                    ; 0490: C6 4D         \n");
    B = (UINT8)(SINT8)0x4d;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STB   <$D0                    ; 0492: D7 D0         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xd0] = B;
                                                     mon("         LDY   #$1ABC                  ; 0494: 10 8E 1A BC   \n");
    Y = 0x1abc;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDA   <$E1                    ; 0498: 96 E1         \n");
    A = (UINT8)memory_DP[0xe1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         DEC   [A,Y]                   ; 049A: 6A B6         \n");
    res = (UINT8)(memory[((memory[(UINT16)(Y + (SINT8)A)]<<8)|memory[(UINT16)(Y + (SINT8)A + 1)])] - 1);
 // N = res;
 // Z = res;
 // V = memory[((memory[(UINT16)(Y + (SINT8)A)]<<8)|memory[(UINT16)(Y + (SINT8)A + 1)])] & ~res;
    memory[((memory[(UINT16)(Y + (SINT8)A)]<<8)|memory[(UINT16)(Y + (SINT8)A + 1)])] = res;
                                                     mon("         LDB   [A,Y]                   ; 049C: E6 B6         \n");
    B = (UINT8)memory[((memory[(UINT16)(Y + (SINT8)A)]<<8)|memory[(UINT16)(Y + (SINT8)A + 1)])];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         EORA  #$02                    ; 049E: 88 02         \n");
    A = A ^ (SINT8)0x02;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORB   [A,Y]                   ; 04A0: EA B6         \n");
    B = B | memory[((memory[(UINT16)(Y + (SINT8)A)]<<8)|memory[(UINT16)(Y + (SINT8)A + 1)])];
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BNE   $04AA                   ; 04A2: 26 06         \n");
    if (Z) {
    PC = 0x04aa;
    JUMP;
    }
                                                     mon("         LDA   <$EC                    ; 04A4: 96 EC         \n");
    A = (UINT8)memory_DP[0xec];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $04AA                   ; 04A6: 26 02         \n");
    if (Z) {
    PC = 0x04aa;
    JUMP;
    }
                                                     mon("         DEC   <$EC                    ; 04A8: 0A EC         \n");
    res = (UINT8)(memory_DP[0xec] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xec] & ~res;
    memory_DP[0xec] = res;
  case 0x04AA:                                       mon("L04AA    LDB   <$D0                    ; 04AA: D6 D0         \n");
    B = (UINT8)memory_DP[0xd0];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  #$0E                    ; 04AC: C0 0E         \n");
    res = B - (SINT8)0x0e;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((B) ^ (SINT8)0x0e) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         LBCS  $058C                   ; 04AE: 10 25 00 DA   \n");
    if (C) {
    PC = 0x058c;
    JUMP;
    }
                                                     mon("         STB   <$9D                    ; 04B2: D7 9D         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x9d] = B;
                                                     mon("         LDA   <$D1                    ; 04B4: 96 D1         \n");
    A = (UINT8)memory_DP[0xd1];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $04F0                   ; 04B6: 26 38         \n");
    if (Z) {
    PC = 0x04f0;
    JUMP;
    }
                                                     mon("         CMPB  #$2F                    ; 04B8: C1 2F         \n");
    res = B - (SINT8)0x2f;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x2f) & (B ^ (UINT8)res);
                                                     mon("         BHI   $04C3                   ; 04BA: 22 07         \n");
    if (Z && (!C)) {
    PC = 0x04c3;
    JUMP;
    }
                                                     mon("         ASLB                          ; 04BC: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 04BD: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ADDB  #$43                    ; 04BE: CB 43         \n");
    res = B + (SINT8)0x43;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = B ^ (SINT8)0x43 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x43 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         NEGB                          ; 04C0: 50            \n");
    V = (UINT8)(-B) & (B);
    C = (-B) & 0x100;
    B = (UINT8)(-B);
    Z = B;
    N = B;
                                                     mon("         BRA   $04CE                   ; 04C1: 20 0B         \n");
    PC = 0x04ce;
    JUMP;
    
  case 0x04C3:                                       mon("L04C3    ANDB  #$0F                    ; 04C3: C4 0F         \n");
    B = B & (SINT8)0x0f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         ASLB                          ; 04C5: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 04C6: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 04C7: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 04C8: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
    N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         BMI   $04CC                   ; 04C9: 2B 01         \n");
    if ((SINT8)N <  0) {
    PC = 0x04cc;
    JUMP;
    }
                                                     mon("         NEGB                          ; 04CB: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x04CC:                                       mon("L04CC    SUBB  #$7F                    ; 04CC: C0 7F         \n");
    res = B - (SINT8)0x7f;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x7f) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
  case 0x04CE:                                       mon("L04CE    PSHS  DP                      ; 04CE: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDA   #$D0                    ; 04D0: 86 D0         \n");
    A = (UINT8)(SINT8)0xd0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 04D2: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
                                                     mon("         STB   <$06                    ; 04D4: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
                                                     mon("         LDA   $C89D                   ; 04D6: B6 C8 9D      \n");
    A = (UINT8)memory[0xc89d];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 04D9: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         JSR   Intensity_a             ; 04DA: BD F2 AB      \n");
    memory[--S] = 0x04dd & 0xff; memory[--S] = 0x04dd >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x04DD:                                       mon("L04DD    LDA   #$CE                    ; 04DD: 86 CE         \n");
    A = (UINT8)(SINT8)0xce;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0C                    ; 04DF: 97 0C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0c] = A;
                                                     mon("         LDX   #$1DFA                  ; 04E1: 8E 1D FA      \n");
    X = 0x1dfa;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $16BE                   ; 04E4: BD 16 BE      \n");
    memory[--S] = 0x04e7 & 0xff; memory[--S] = 0x04e7 >> 8;
    PC = 0x16be;
    JUMP;
  case 0x04E7:                                       mon("L04E7    LDA   #$CE                    ; 04E7: 86 CE         \n");
    A = (UINT8)(SINT8)0xce;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0C                    ; 04E9: 97 0C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0c] = A;
                                                     mon("         JSR   $16BE                   ; 04EB: BD 16 BE      \n");
    memory[--S] = 0x04ee & 0xff; memory[--S] = 0x04ee >> 8;
    PC = 0x16be;
    JUMP;
  case 0x04EE:                                       mon("L04EE    PULS  DP                      ; 04EE: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
  case 0x04F0:                                       mon("L04F0    LDA   <$EB                    ; 04F0: 96 EB         \n");
    A = (UINT8)memory_DP[0xeb];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  #$04                    ; 04F2: 80 04         \n");
    res = A - (SINT8)0x04;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x04) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BCC   $04F7                   ; 04F4: 24 01         \n");
    if (!C) {
    PC = 0x04f7;
    JUMP;
    }
                                                     mon("         CLRA                          ; 04F6: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x04F7:                                       mon("L04F7    STA   <$EB                    ; 04F7: 97 EB         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xeb] = A;
                                                     mon("         LDA   <$C1                    ; 04F9: 96 C1         \n");
    A = (UINT8)memory_DP[0xc1];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0502                   ; 04FB: 27 05         \n");
    if (!Z) {
    PC = 0x0502;
    JUMP;
    }
                                                     mon("         JSR   $0B1E                   ; 04FD: BD 0B 1E      \n");
    memory[--S] = 0x0500 & 0xff; memory[--S] = 0x0500 >> 8;
    PC = 0x0b1e;
    JUMP;
  case 0x0500:                                       mon("L0500    STA   <$C1                    ; 0500: 97 C1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc1] = A;
  case 0x0502:                                       mon("L0502    LDD   <$EF                    ; 0502: DC EF         \n");
    A = memory_DP[0xef];
    B = memory_DP[0xef + 1];
    Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $050F                   ; 0504: 27 09         \n");
    if (!Z) {
    PC = 0x050f;
    JUMP;
    }
                                                     mon("         SUBD  #$0820                  ; 0506: 83 08 20      \n");
    arg = (A << 8) | B;
    res = arg - (0x0820);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x0820)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BCC   $050D                   ; 0509: 24 02         \n");
    if (!C) {
    PC = 0x050d;
    JUMP;
    }
                                                     mon("         CLRA                          ; 050B: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 050C: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
  case 0x050D:                                       mon("L050D    STD   <$EF                    ; 050D: DD EF         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xef] = A;
    memory_DP[0xef + 1] = B;
  case 0x050F:                                       mon("L050F    LDD   <$ED                    ; 050F: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         BEQ   $052A                   ; 0511: 27 17         \n");
    if (!Z) {
    PC = 0x052a;
    JUMP;
    }
                                                     mon("         PSHS  CC                      ; 0513: 34 01         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    memory[--S] = CC;
                                                     mon("         BPL   $051A                   ; 0515: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x051a;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0517: BD 19 CB      \n");
    memory[--S] = 0x051a & 0xff; memory[--S] = 0x051a >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x051A:                                       mon("L051A    SUBD  #$38                    ; 051A: 83 00 38      \n");
    arg = (A << 8) | B;
    res = arg - (0x0038);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x0038)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BPL   $0521                   ; 051D: 2A 02         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0521;
    JUMP;
    }
                                                     mon("         CLRA                          ; 051F: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 0520: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0521:                                       mon("L0521    PULS  CC                      ; 0521: 35 01         \n");
    CC = memory[S++];
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         BPL   $0528                   ; 0523: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0528;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0525: BD 19 CB      \n");
    memory[--S] = 0x0528 & 0xff; memory[--S] = 0x0528 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0528:                                       mon("L0528    STD   <$ED                    ; 0528: DD ED         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xed] = A;
    memory_DP[0xed + 1] = B;
  case 0x052A:                                       mon("L052A    LDX   #$1F91                  ; 052A: 8E 1F 91      \n");
    X = 0x1f91;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #$CA73                  ; 052D: CE CA 73      \n");
    U = 0xca73;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDB   <$26                    ; 0530: D6 26         \n");
    B = (UINT8)memory_DP[0x26];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDB  #$1F                    ; 0532: C4 1F         \n");
    B = B & (SINT8)0x1f;
 // Z = B;
 // N = B;
 // V = 0;
  case 0x0534:                                       mon("L0534    CMPB  #$18                    ; 0534: C1 18         \n");
    res = B - (SINT8)0x18;
 // C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
    V = (B ^ (SINT8)0x18) & (B ^ (UINT8)res);
                                                     mon("         BLT   $053A                   ; 0536: 2D 02         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x053a;
    JUMP;
    }
                                                     mon("         SUBB  #$18                    ; 0538: C0 18         \n");
    res = B - (SINT8)0x18;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x18) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
  case 0x053A:                                       mon("L053A    LDA   B,X                     ; 053A: A6 85         \n");
    A = (UINT8)memory[(UINT16)(X + (SINT8)B)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   ,U+                     ; 053C: A7 C0         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[U] = A;
    U = U + 1;
                                                     mon("         INCB                          ; 053E: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
                                                     mon("         CMPU  #$CA8B                  ; 053F: 11 83 CA 8B   \n");
    res = (U) - (0xca8b);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((U) ^ (0xca8b)) & ((U) ^ res)) >> 8;
                                                     mon("         BCS   $0534                   ; 0543: 25 EF         \n");
    if (C) {
    PC = 0x0534;
    JUMP;
    }
                                                     mon("         LDD   #$80                    ; 0545: CC 00 80      \n");
    A = (UINT8)((0x0080) >> 8);
    B = (UINT8)((0x0080) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   ,U++                    ; 0548: ED C1         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[U] = A;
    memory[U + 1] = B;
    U = U + 2;
                                                     mon("         JSR   $10F6                   ; 054A: BD 10 F6      \n");
    memory[--S] = 0x054d & 0xff; memory[--S] = 0x054d >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x054D:                                       mon("L054D    SEX                           ; 054D: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ORA   #$01                    ; 054E: 8A 01         \n");
    A = A | (SINT8)0x01;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ADDA  <$CD                    ; 0550: 9B CD         \n");
    res = A + memory_DP[0xcd];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory_DP[0xcd] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0xcd] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         CMPA  #$01                    ; 0552: 81 01         \n");
    res = A - (SINT8)0x01;
 // C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0x01) & (A ^ (UINT8)res);
                                                     mon("         BGT   $055C                   ; 0554: 2E 06         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x055c;
    JUMP;
    }
                                                     mon("         CMPA  #$FF                    ; 0556: 81 FF         \n");
    res = A - (SINT8)0xff;
 // C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0xff) & (A ^ (UINT8)res);
                                                     mon("         BLT   $055C                   ; 0558: 2D 02         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x055c;
    JUMP;
    }
                                                     mon("         STA   <$CD                    ; 055A: 97 CD         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xcd] = A;
  case 0x055C:                                       mon("L055C    LDA   <$CD                    ; 055C: 96 CD         \n");
    A = (UINT8)memory_DP[0xcd];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   #$50                    ; 055E: C6 50         \n");
    B = (UINT8)(SINT8)0x50;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STD   <$2A                    ; 0560: DD 2A         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x2a] = A;
    memory_DP[0x2a + 1] = B;
                                                     mon("         PSHS  DP                      ; 0562: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_D0                ; 0564: BD F1 AA      \n");
    memory[--S] = 0x0567 & 0xff; memory[--S] = 0x0567 >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x0567:                                       mon("L0567    JSR   Intensity_7F            ; 0567: BD F2 A9      \n");
    memory[--S] = 0x056a & 0xff; memory[--S] = 0x056a >> 8;
    PC = 0xf2a9;
    JUMP;
  case 0x056A:                                       mon("L056A    LDA   $C89D                   ; 056A: B6 C8 9D      \n");
    A = (UINT8)memory[0xc89d];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 056D: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 056E: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         PSHS  A                       ; 056F: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDD   #$7F80                  ; 0571: CC 7F 80      \n");
    A = (UINT8)((0x7f80) >> 8);
    B = (UINT8)((0x7f80) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 0574: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         JSR   Moveto_d_7F             ; 0576: BD F2 FC      \n");
    memory[--S] = 0x0579 & 0xff; memory[--S] = 0x0579 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x0579:                                       mon("L0579    LDX   #$1EBF                  ; 0579: 8E 1E BF      \n");
    X = 0x1ebf;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   ,X++                    ; 057C: EC 81         \n");
    A = memory[X];
    B = memory[(UINT16)((X)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    X = X + 2;
                                                     mon("         JSR   $0FFF                   ; 057E: BD 0F FF      \n");
    memory[--S] = 0x0581 & 0xff; memory[--S] = 0x0581 >> 8;
    PC = 0x0fff;
    JUMP;
  case 0x0581:                                       mon("L0581    LDU   #$CA73                  ; 0581: CE CA 73      \n");
    U = 0xca73;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1033                   ; 0584: BD 10 33      \n");
    memory[--S] = 0x0587 & 0xff; memory[--S] = 0x0587 >> 8;
    PC = 0x1033;
    JUMP;
  case 0x0587:                                       mon("L0587    JSR   $0FF9                   ; 0587: BD 0F F9      \n");
    memory[--S] = 0x058a & 0xff; memory[--S] = 0x058a >> 8;
    PC = 0x0ff9;
    JUMP;
  case 0x058A:                                       mon("L058A    PULS  DP                      ; 058A: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
  case 0x058C:                                       mon("L058C    DEC   <$D0                    ; 058C: 0A D0         \n");
    res = (UINT8)(memory_DP[0xd0] - 1);
 // N = res;
    Z = res;
 // V = memory_DP[0xd0] & ~res;
    memory_DP[0xd0] = res;
                                                     mon("         BNE   $05AE                   ; 058E: 26 1E         \n");
    if (Z) {
    PC = 0x05ae;
    JUMP;
    }
                                                     mon("         LDA   <$77                    ; 0590: 96 77         \n");
    A = (UINT8)memory_DP[0x77];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$56                    ; 0592: 9A 56         \n");
    A = A | memory_DP[0x56];
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $059A                   ; 0594: 27 04         \n");
    if (!Z) {
    PC = 0x059a;
    JUMP;
    }
                                                     mon("         INC   <$D0                    ; 0596: 0C D0         \n");
    res = (UINT8)(memory_DP[0xd0] + 1);
    Z = res;
    N = res;
    V = res & ~(memory_DP[0xd0]);
    memory_DP[0xd0] = res;
                                                     mon("         BRA   $05AE                   ; 0598: 20 14         \n");
    PC = 0x05ae;
    JUMP;
    
  case 0x059A:                                       mon("L059A    LDA   <$E1                    ; 059A: 96 E1         \n");
    A = (UINT8)memory_DP[0xe1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$79                    ; 059C: D6 79         \n");
    B = (UINT8)memory_DP[0x79];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $05A4                   ; 059E: 27 04         \n");
    if (!Z) {
    PC = 0x05a4;
    JUMP;
    }
                                                     mon("         EORA  #$02                    ; 05A0: 88 02         \n");
    A = A ^ (SINT8)0x02;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$E1                    ; 05A2: 97 E1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xe1] = A;
  case 0x05A4:                                       mon("L05A4    JSR   Init_Music_Buf          ; 05A4: BD F5 33      \n");
    memory[--S] = 0x05a7 & 0xff; memory[--S] = 0x05a7 >> 8;
    PC = 0xf533;
    JUMP;
  case 0x05A7:                                       mon("L05A7    LDA   <$EC                    ; 05A7: 96 EC         \n");
    A = (UINT8)memory_DP[0xec];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BNE   $05AE                   ; 05A9: 26 03         \n");
    if (Z) {
    PC = 0x05ae;
    JUMP;
    }
                                                     mon("         JMP   $6A                     ; 05AB: 7E 00 6A      \n");
    PC = 0x006a;
    JUMP;
    
  case 0x05AE:                                       mon("L05AE    JSR   Random                  ; 05AE: BD F5 17      \n");
    memory[--S] = 0x05b1 & 0xff; memory[--S] = 0x05b1 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x05B1:                                       mon("L05B1    BNE   $05C1                   ; 05B1: 26 0E         \n");
    if (Z) {
    PC = 0x05c1;
    JUMP;
    }
                                                     mon("         LDA   #$03                    ; 05B3: 86 03         \n");
    A = (UINT8)(SINT8)0x03;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $1149                   ; 05B5: BD 11 49      \n");
    memory[--S] = 0x05b8 & 0xff; memory[--S] = 0x05b8 >> 8;
    PC = 0x1149;
    JUMP;
  case 0x05B8:                                       mon("L05B8    BCS   $05C1                   ; 05B8: 25 07         \n");
    if (C) {
    PC = 0x05c1;
    JUMP;
    }
                                                     mon("         JSR   $10FC                   ; 05BA: BD 10 FC      \n");
    memory[--S] = 0x05bd & 0xff; memory[--S] = 0x05bd >> 8;
    PC = 0x10fc;
    JUMP;
  case 0x05BD:                                       mon("L05BD    LDA   #$08                    ; 05BD: 86 08         \n");
    A = (UINT8)(SINT8)0x08;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 05BF: A7 4B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
  case 0x05C1:                                       mon("L05C1    LDA   <$CA                    ; 05C1: 96 CA         \n");
    A = (UINT8)memory_DP[0xca];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $05C9                   ; 05C3: 27 04         \n");
    if (!Z) {
    PC = 0x05c9;
    JUMP;
    }
                                                     mon("         DEC   <$CA                    ; 05C5: 0A CA         \n");
    res = (UINT8)(memory_DP[0xca] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xca] & ~res;
    memory_DP[0xca] = res;
                                                     mon("         BRA   $05DC                   ; 05C7: 20 13         \n");
    PC = 0x05dc;
    JUMP;
    
  case 0x05C9:                                       mon("L05C9    LDA   <$ED                    ; 05C9: 96 ED         \n");
    A = (UINT8)memory_DP[0xed];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $05CE                   ; 05CB: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x05ce;
    JUMP;
    }
                                                     mon("         NEGA                          ; 05CD: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x05CE:                                       mon("L05CE    PSHS  A                       ; 05CE: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   <$C9                    ; 05D0: 96 C9         \n");
    A = (UINT8)memory_DP[0xc9];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 05D2: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         STA   <$C9                    ; 05D4: 97 C9         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc9] = A;
                                                     mon("         BCC   $05E6                   ; 05D6: 24 0E         \n");
    if (!C) {
    PC = 0x05e6;
    JUMP;
    }
                                                     mon("         LDA   #$02                    ; 05D8: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$CA                    ; 05DA: 97 CA         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xca] = A;
  case 0x05DC:                                       mon("L05DC    LDA   #$02                    ; 05DC: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $1149                   ; 05DE: BD 11 49      \n");
    memory[--S] = 0x05e1 & 0xff; memory[--S] = 0x05e1 >> 8;
    PC = 0x1149;
    JUMP;
  case 0x05E1:                                       mon("L05E1    BCS   $05E6                   ; 05E1: 25 03         \n");
    if (C) {
    PC = 0x05e6;
    JUMP;
    }
                                                     mon("         JSR   $10FC                   ; 05E3: BD 10 FC      \n");
    memory[--S] = 0x05e6 & 0xff; memory[--S] = 0x05e6 >> 8;
    PC = 0x10fc;
    JUMP;
  case 0x05E6:                                       mon("L05E6    JSR   Random                  ; 05E6: BD F5 17      \n");
    memory[--S] = 0x05e9 & 0xff; memory[--S] = 0x05e9 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x05E9:                                       mon("L05E9    ANDA  #$24                    ; 05E9: 84 24         \n");
    A = A & (SINT8)0x24;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$CF                    ; 05EB: 97 CF         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xcf] = A;
                                                     mon("         LDA   #$04                    ; 05ED: 86 04         \n");
    A = (UINT8)(SINT8)0x04;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $1149                   ; 05EF: BD 11 49      \n");
    memory[--S] = 0x05f2 & 0xff; memory[--S] = 0x05f2 >> 8;
    PC = 0x1149;
    JUMP;
  case 0x05F2:                                       mon("L05F2    BCS   $061E                   ; 05F2: 25 2A         \n");
    if (C) {
    PC = 0x061e;
    JUMP;
    }
                                                     mon("         LDA   <$26                    ; 05F4: 96 26         \n");
    A = (UINT8)memory_DP[0x26];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$01                    ; 05F6: 84 01         \n");
    A = A & (SINT8)0x01;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 05F8: A7 4B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
                                                     mon("         LDA   <$CF                    ; 05FA: 96 CF         \n");
    A = (UINT8)memory_DP[0xcf];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0610                   ; 05FC: 27 12         \n");
    if (!Z) {
    PC = 0x0610;
    JUMP;
    }
                                                     mon("         JSR   $10F6                   ; 05FE: BD 10 F6      \n");
    memory[--S] = 0x0601 & 0xff; memory[--S] = 0x0601 >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x0601:                                       mon("L0601    SEX                           ; 0601: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$80                    ; 0602: D3 80         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x80]<<8)|memory_DP[0x80 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 0604: ED 40         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         JSR   $10F6                   ; 0606: BD 10 F6      \n");
    memory[--S] = 0x0609 & 0xff; memory[--S] = 0x0609 >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x0609:                                       mon("L0609    SEX                           ; 0609: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$84                    ; 060A: D3 84         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x84]<<8)|memory_DP[0x84 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 060C: ED 44         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         BRA   $0613                   ; 060E: 20 03         \n");
    PC = 0x0613;
    JUMP;
    
  case 0x0610:                                       mon("L0610    JSR   $10FC                   ; 0610: BD 10 FC      \n");
    memory[--S] = 0x0613 & 0xff; memory[--S] = 0x0613 >> 8;
    PC = 0x10fc;
    JUMP;
  case 0x0613:                                       mon("L0613    LDA   #$FF                    ; 0613: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $09,U                   ; 0615: A7 49         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0009)] = A;
                                                     mon("         LDD   #$60                    ; 0617: CC 00 60      \n");
    A = (UINT8)((0x0060) >> 8);
    B = (UINT8)((0x0060) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ADDD  <$82                    ; 061A: D3 82         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x82]<<8)|memory_DP[0x82 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 061C: ED 42         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
  case 0x061E:                                       mon("L061E    LDA   <$CE                    ; 061E: 96 CE         \n");
    A = (UINT8)memory_DP[0xce];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0643                   ; 0620: 26 21         \n");
    if (Z) {
    PC = 0x0643;
    JUMP;
    }
                                                     mon("         LDD   <$80                    ; 0622: DC 80         \n");
    A = memory_DP[0x80];
    B = memory_DP[0x80 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$91                    ; 0624: 93 91         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x91]<<8)|memory_DP[0x91 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x91]<<8)|memory_DP[0x91 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BPL   $062B                   ; 0626: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x062b;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0628: BD 19 CB      \n");
    memory[--S] = 0x062b & 0xff; memory[--S] = 0x062b >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x062B:                                       mon("L062B    CMPD  <$F9                    ; 062B: 10 93 F9      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xf9]<<8)|memory_DP[0xf9 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xf9]<<8)|memory_DP[0xf9 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BHI   $063E                   ; 062E: 22 0E         \n");
    if (Z && (!C)) {
    PC = 0x063e;
    JUMP;
    }
                                                     mon("         LDD   <$84                    ; 0630: DC 84         \n");
    A = memory_DP[0x84];
    B = memory_DP[0x84 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$95                    ; 0632: 93 95         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x95]<<8)|memory_DP[0x95 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x95]<<8)|memory_DP[0x95 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BPL   $0639                   ; 0634: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0639;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0636: BD 19 CB      \n");
    memory[--S] = 0x0639 & 0xff; memory[--S] = 0x0639 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0639:                                       mon("L0639    CMPD  <$F9                    ; 0639: 10 93 F9      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xf9]<<8)|memory_DP[0xf9 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xf9]<<8)|memory_DP[0xf9 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLS   $0647                   ; 063C: 23 09         \n");
    if ((!Z) || C) {
    PC = 0x0647;
    JUMP;
    }
  case 0x063E:                                       mon("L063E    DEC   <$CE                    ; 063E: 0A CE         \n");
    res = (UINT8)(memory_DP[0xce] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xce] & ~res;
    memory_DP[0xce] = res;
                                                     mon("         JSR   $10B9                   ; 0640: BD 10 B9      \n");
    memory[--S] = 0x0643 & 0xff; memory[--S] = 0x0643 >> 8;
    PC = 0x10b9;
    JUMP;
  case 0x0643:                                       mon("L0643    LDA   <$CE                    ; 0643: 96 CE         \n");
    A = (UINT8)memory_DP[0xce];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BNE   $064A                   ; 0645: 26 03         \n");
    if (Z) {
    PC = 0x064a;
    JUMP;
    }
  case 0x0647:                                       mon("L0647    JMP   $06D4                   ; 0647: 7E 06 D4      \n");
    PC = 0x06d4;
    JUMP;
    
  case 0x064A:                                       mon("L064A    LDA   <$26                    ; 064A: 96 26         \n");
    A = (UINT8)memory_DP[0x26];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$01                    ; 064C: 84 01         \n");
    A = A & (SINT8)0x01;
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $0661                   ; 064E: 27 11         \n");
    if (!Z) {
    PC = 0x0661;
    JUMP;
    }
                                                     mon("         LDA   <$D2                    ; 0650: 96 D2         \n");
    A = (UINT8)memory_DP[0xd2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $065A                   ; 0652: 26 06         \n");
    if (Z) {
    PC = 0x065a;
    JUMP;
    }
                                                     mon("         DEC   <$CE                    ; 0654: 0A CE         \n");
    res = (UINT8)(memory_DP[0xce] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xce] & ~res;
    memory_DP[0xce] = res;
                                                     mon("         LBEQ  $99                     ; 0656: 10 27 FA 3F   \n");
    if (!Z) {
    PC = 0x0099;
    JUMP;
    }
  case 0x065A:                                       mon("L065A    LDA   <$86                    ; 065A: 96 86         \n");
    A = (UINT8)memory_DP[0x86];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         INCA                          ; 065C: 4C            \n");
    res = (UINT8)(A + 1);
 // Z = res;
 // N = res;
 // V = res & ~(A);
    A = res;
                                                     mon("         ANDA  #$3F                    ; 065D: 84 3F         \n");
    A = A & (SINT8)0x3f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$86                    ; 065F: 97 86         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x86] = A;
  case 0x0661:                                       mon("L0661    PSHS  DP                      ; 0661: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_D0                ; 0663: BD F1 AA      \n");
    memory[--S] = 0x0666 & 0xff; memory[--S] = 0x0666 >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x0666:                                       mon("L0666    LDA   #$02                    ; 0666: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $C89F                   ; 0668: B7 C8 9F      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc89f] = A;
  case 0x066B:                                       mon("L066B    LDB   #$03                    ; 066B: C6 03         \n");
    B = (UINT8)(SINT8)0x03;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x066D:                                       mon("L066D    STB   $C89E                   ; 066D: F7 C8 9E      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc89e] = B;
                                                     mon("         LDA   #$10                    ; 0670: 86 10         \n");
    A = (UINT8)(SINT8)0x10;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         MUL                           ; 0672: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ANDB  #$7F                    ; 0673: C4 7F         \n");
    B = B & (SINT8)0x7f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         CMPB  #$18                    ; 0675: C1 18         \n");
    res = B - (SINT8)0x18;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x18) & (B ^ (UINT8)res);
                                                     mon("         BLS   $06C7                   ; 0677: 23 4E         \n");
    if ((!Z) || C) {
    PC = 0x06c7;
    JUMP;
    }
                                                     mon("         STB   <$06                    ; 0679: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
                                                     mon("         LDB   $C8CE                   ; 067B: F6 C8 CE      \n");
    B = (UINT8)memory[0xc8ce];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Abs_b                   ; 067E: BD F5 8B      \n");
    memory[--S] = 0x0681 & 0xff; memory[--S] = 0x0681 >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x0681:                                       mon("L0681    STB   $C897                   ; 0681: F7 C8 97      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc897] = B;
                                                     mon("         ASLB                          ; 0684: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         STB   $C898                   ; 0685: F7 C8 98      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc898] = B;
                                                     mon("         CLRB                          ; 0688: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         SUBB  $C898                   ; 0689: F0 C8 98      \n");
    res = B - memory[0xc898];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[0xc898]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         STB   $C8EB                   ; 068C: F7 C8 EB      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc8eb] = B;
                                                     mon("         LDA   $C897                   ; 068F: B6 C8 97      \n");
    A = (UINT8)memory[0xc897];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Intensity_a             ; 0692: BD F2 AB      \n");
    memory[--S] = 0x0695 & 0xff; memory[--S] = 0x0695 >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x0695:                                       mon("L0695    LDX   #$1C32                  ; 0695: 8E 1C 32      \n");
    X = 0x1c32;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDA   #$08                    ; 0698: 86 08         \n");
    A = (UINT8)(SINT8)0x08;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $C89E                   ; 069A: F6 C8 9E      \n");
    B = (UINT8)memory[0xc89e];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 069D: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         LEAX  B,X                     ; 069E: 30 85         \n");
    X = (X + (SINT8)B);
 // Z = X;
                                                     mon("         LDU   #$CA73                  ; 06A0: CE CA 73      \n");
    U = 0xca73;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   $C826                   ; 06A3: B6 C8 26      \n");
    A = (UINT8)memory[0xc826];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 06A6: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         LDB   #$02                    ; 06A7: C6 02         \n");
    B = (UINT8)(SINT8)0x02;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Rot_VL_ab               ; 06A9: BD F6 10      \n");
    memory[--S] = 0x06ac & 0xff; memory[--S] = 0x06ac >> 8;
    PC = 0xf610;
    JUMP;
  case 0x06AC:                                       mon("L06AC    LDA   #$40                    ; 06AC: 86 40         \n");
    A = (UINT8)(SINT8)0x40;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $C89F                   ; 06AE: F6 C8 9F      \n");
    B = (UINT8)memory[0xc89f];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 06B1: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         SUBB  #$40                    ; 06B2: C0 40         \n");
    res = B - (SINT8)0x40;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x40) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         LDA   #$1F                    ; 06B4: 86 1F         \n");
    A = (UINT8)(SINT8)0x1f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 06B6: BD F2 FC      \n");
    memory[--S] = 0x06b9 & 0xff; memory[--S] = 0x06b9 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x06B9:                                       mon("L06B9    LDX   #$CA73                  ; 06B9: 8E CA 73      \n");
    X = 0xca73;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDA   #$02                    ; 06BC: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   Vec_Misc_Count          ; 06BE: B7 C8 23      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc823] = A;
                                                     mon("         JSR   Dot_List                ; 06C1: BD F2 D5      \n");
    memory[--S] = 0x06c4 & 0xff; memory[--S] = 0x06c4 >> 8;
    PC = 0xf2d5;
    JUMP;
  case 0x06C4:                                       mon("L06C4    JSR   Reset0Ref               ; 06C4: BD F3 54      \n");
    memory[--S] = 0x06c7 & 0xff; memory[--S] = 0x06c7 >> 8;
    PC = 0xf354;
    JUMP;
  case 0x06C7:                                       mon("L06C7    LDB   $C89E                   ; 06C7: F6 C8 9E      \n");
    B = (UINT8)memory[0xc89e];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         DECB                          ; 06CA: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         BPL   $066D                   ; 06CB: 2A A0         \n");
    if ((SINT8)N >= 0) {
    PC = 0x066d;
    JUMP;
    }
                                                     mon("         DEC   $C89F                   ; 06CD: 7A C8 9F      \n");
    res = (UINT8)(memory[0xc89f] - 1);
    N = res;
 // Z = res;
 // V = memory[0xc89f] & ~res;
    memory[0xc89f] = res;
                                                     mon("         BPL   $066B                   ; 06D0: 2A 99         \n");
    if ((SINT8)N >= 0) {
    PC = 0x066b;
    JUMP;
    }
                                                     mon("         PULS  DP                      ; 06D2: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
  case 0x06D4:                                       mon("L06D4    LDA   <$BF                    ; 06D4: 96 BF         \n");
    A = (UINT8)memory_DP[0xbf];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $06DA                   ; 06D6: 27 02         \n");
    if (!Z) {
    PC = 0x06da;
    JUMP;
    }
                                                     mon("         DEC   <$BF                    ; 06D8: 0A BF         \n");
    res = (UINT8)(memory_DP[0xbf] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xbf] & ~res;
    memory_DP[0xbf] = res;
  case 0x06DA:                                       mon("L06DA    LDU   #$C900                  ; 06DA: CE C9 00      \n");
    U = 0xc900;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
  case 0x06DD:                                       mon("L06DD    LDX   #$1AC4                  ; 06DD: 8E 1A C4      \n");
    X = 0x1ac4;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   $07,U                   ; 06E0: E6 47         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0007)];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BMI   $0712                   ; 06E2: 2B 2E         \n");
    if ((SINT8)N <  0) {
    PC = 0x0712;
    JUMP;
    }
                                                     mon("         ASLB                          ; 06E4: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 06E5: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ABX                           ; 06E6: 3A            \n");
    X = X + B;
                                                     mon("         LDA   <$D0                    ; 06E7: 96 D0         \n");
    A = (UINT8)memory_DP[0xd0];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $06F1                   ; 06E9: 27 06         \n");
    if (!Z) {
    PC = 0x06f1;
    JUMP;
    }
                                                     mon("         LDA   <$D1                    ; 06EB: 96 D1         \n");
    A = (UINT8)memory_DP[0xd1];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $06F1                   ; 06ED: 26 02         \n");
    if (Z) {
    PC = 0x06f1;
    JUMP;
    }
                                                     mon("         INC   $0D,U                   ; 06EF: 6C 4D         \n");
    res = (UINT8)(memory[(UINT16)(U + 0x000d)] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory[(UINT16)(U + 0x000d)]);
    memory[(UINT16)(U + 0x000d)] = res;
  case 0x06F1:                                       mon("L06F1    LDA   $0D,U                   ; 06F1: A6 4D         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000d)];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0704                   ; 06F3: 27 0F         \n");
    if (!Z) {
    PC = 0x0704;
    JUMP;
    }
                                                     mon("         ADDA  #$08                    ; 06F5: 8B 08         \n");
    res = A + (SINT8)0x08;
    C = (res >> 1) & 0x80;
    Z = (UINT8)res;
    N = (UINT8)res;
    H = A ^ (SINT8)0x08 ^ (UINT8)res ^ C;
    V = A ^ (SINT8)0x08 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         BCC   $06FE                   ; 06F7: 24 05         \n");
    if (!C) {
    PC = 0x06fe;
    JUMP;
    }
                                                     mon("         JSR   $119F                   ; 06F9: BD 11 9F      \n");
    memory[--S] = 0x06fc & 0xff; memory[--S] = 0x06fc >> 8;
    PC = 0x119f;
    JUMP;
  case 0x06FC:                                       mon("L06FC    BRA   $0712                   ; 06FC: 20 14         \n");
    PC = 0x0712;
    JUMP;
    
  case 0x06FE:                                       mon("L06FE    STA   $0D,U                   ; 06FE: A7 4D         \n");
 // Z = A;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x000d)] = A;
  case 0x0700:                                       mon("L0700    LEAX  $02,X                   ; 0700: 30 02         \n");
    X = (X + 0x0002);
    Z = X;
                                                     mon("         BRA   $070E                   ; 0702: 20 0A         \n");
    PC = 0x070e;
    JUMP;
    
  case 0x0704:                                       mon("L0704    LDA   <$D2                    ; 0704: 96 D2         \n");
    A = (UINT8)memory_DP[0xd2];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$EC                    ; 0706: 9A EC         \n");
    A = A | memory_DP[0xec];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$D0                    ; 0708: 9A D0         \n");
    A = A | memory_DP[0xd0];
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BNE   $0700                   ; 070A: 26 F4         \n");
    if (Z) {
    PC = 0x0700;
    JUMP;
    }
                                                     mon("         JSR   [,X++]                  ; 070C: AD 91         \n");
    memory[--S] = 0x070e & 0xff; memory[--S] = 0x070e >> 8;
    PC = ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
    X = X + 2;
    JUMP;
  case 0x070E:                                       mon("L070E    LDX   ,X                      ; 070E: AE 84         \n");
    X = ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   [,X++]                  ; 0710: AD 91         \n");
    memory[--S] = 0x0712 & 0xff; memory[--S] = 0x0712 >> 8;
    PC = ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
    X = X + 2;
    JUMP;
  case 0x0712:                                       mon("L0712    LEAU  $10,U                   ; 0712: 33 C8 10      \n");
    U = (U + (SINT8)0x10);
                                                     mon("         CMPU  #$C9F0                  ; 0715: 11 83 C9 F0   \n");
    res = (U) - (0xc9f0);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((U) ^ (0xc9f0)) & ((U) ^ res)) >> 8;
                                                     mon("         BCS   $06DD                   ; 0719: 25 C2         \n");
    if (C) {
    PC = 0x06dd;
    JUMP;
    }
                                                     mon("         LDA   <$BF                    ; 071B: 96 BF         \n");
    A = (UINT8)memory_DP[0xbf];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$BE                    ; 071D: 97 BE         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xbe] = A;
                                                     mon("         LDY   #$1AD8                  ; 071F: 10 8E 1A D8   \n");
    Y = 0x1ad8;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
  case 0x0723:                                       mon("L0723    LDU   ,Y++                    ; 0723: EE A1         \n");
    U = ((memory[Y]<<8)|memory[(UINT16)((Y)+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
    Y = Y + 2;
                                                     mon("         LEAY  $02,Y                   ; 0725: 31 22         \n");
    Y = (Y + 0x0002);
 // Z = Y;
                                                     mon("         PSHS  Y                       ; 0727: 34 20         \n");
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
  case 0x0729:                                       mon("L0729    LDX   ,Y++                    ; 0729: AE A1         \n");
    X = ((memory[Y]<<8)|memory[(UINT16)((Y)+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
    Y = Y + 2;
                                                     mon("         LDD   ,Y++                    ; 072B: EC A1         \n");
    A = memory[Y];
    B = memory[(UINT16)((Y)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    Y = Y + 2;
                                                     mon("         STD   <$DD                    ; 072D: DD DD         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xdd] = A;
    memory_DP[0xdd + 1] = B;
                                                     mon("         CMPX  #$CA3D                  ; 072F: 8C CA 3D      \n");
    res = (X) - (0xca3d);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = (((X) ^ (0xca3d)) & ((X) ^ res)) >> 8;
                                                     mon("         BNE   $073A                   ; 0732: 26 06         \n");
    if (Z) {
    PC = 0x073a;
    JUMP;
    }
                                                     mon("         CMPU  #$CA31                  ; 0734: 11 83 CA 31   \n");
    res = (U) - (0xca31);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = (((U) ^ (0xca31)) & ((U) ^ res)) >> 8;
                                                     mon("         BEQ   $073D                   ; 0738: 27 03         \n");
    if (!Z) {
    PC = 0x073d;
    JUMP;
    }
  case 0x073A:                                       mon("L073A    JSR   $11FD                   ; 073A: BD 11 FD      \n");
    memory[--S] = 0x073d & 0xff; memory[--S] = 0x073d >> 8;
    PC = 0x11fd;
    JUMP;
  case 0x073D:                                       mon("L073D    CMPY  #$1AEC                  ; 073D: 10 8C 1A EC   \n");
    res = (Y) - (0x1aec);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((Y) ^ (0x1aec)) & ((Y) ^ res)) >> 8;
                                                     mon("         BCS   $0729                   ; 0741: 25 E6         \n");
    if (C) {
    PC = 0x0729;
    JUMP;
    }
                                                     mon("         PULS  Y                       ; 0743: 35 20         \n");
    Y = memory[S++]<<8;
    Y |= memory[S++];
                                                     mon("         CMPY  #$1AEC                  ; 0745: 10 8C 1A EC   \n");
    res = (Y) - (0x1aec);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((Y) ^ (0x1aec)) & ((Y) ^ res)) >> 8;
                                                     mon("         BCS   $0723                   ; 0749: 25 D8         \n");
    if (C) {
    PC = 0x0723;
    JUMP;
    }
                                                     mon("         LDU   #$C891                  ; 074B: CE C8 91      \n");
    U = 0xc891;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDX   #$1B81                  ; 074E: 8E 1B 81      \n");
    X = 0x1b81;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $139C                   ; 0751: BD 13 9C      \n");
    memory[--S] = 0x0754 & 0xff; memory[--S] = 0x0754 >> 8;
    PC = 0x139c;
    JUMP;
  case 0x0754:                                       mon("L0754    LDD   #$C0                    ; 0754: CC 00 C0      \n");
    A = (UINT8)((0x00c0) >> 8);
    B = (UINT8)((0x00c0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12A4                   ; 0757: BD 12 A4      \n");
    memory[--S] = 0x075a & 0xff; memory[--S] = 0x075a >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x075A:                                       mon("L075A    BCS   $075E                   ; 075A: 25 02         \n");
    if (C) {
    PC = 0x075e;
    JUMP;
    }
                                                     mon("         CLR   <$BD                    ; 075C: 0F BD         \n");
    memory_DP[0xbd] = 0;
    V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
  case 0x075E:                                       mon("L075E    JSR   $1314                   ; 075E: BD 13 14      \n");
    memory[--S] = 0x0761 & 0xff; memory[--S] = 0x0761 >> 8;
    PC = 0x1314;
    JUMP;
  case 0x0761:                                       mon("L0761    BCC   $0768                   ; 0761: 24 05         \n");
    if (!C) {
    PC = 0x0768;
    JUMP;
    }
                                                     mon("         JSR   $1320                   ; 0763: BD 13 20      \n");
    memory[--S] = 0x0766 & 0xff; memory[--S] = 0x0766 >> 8;
    PC = 0x1320;
    JUMP;
  case 0x0766:                                       mon("L0766    BVC   $0777                   ; 0766: 28 0F         \n");
    if ((SINT8)V >= 0) {
    PC = 0x0777;
    JUMP;
    }
  case 0x0768:                                       mon("L0768    LDA   <$BD                    ; 0768: 96 BD         \n");
    A = (UINT8)memory_DP[0xbd];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0770                   ; 076A: 26 04         \n");
    if (Z) {
    PC = 0x0770;
    JUMP;
    }
                                                     mon("         LDD   <$82                    ; 076C: DC 82         \n");
    A = memory_DP[0x82];
    B = memory_DP[0x82 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$93                    ; 076E: DD 93         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x93] = A;
    memory_DP[0x93 + 1] = B;
  case 0x0770:                                       mon("L0770    LDA   #$01                    ; 0770: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$BD                    ; 0772: 97 BD         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0xbd] = A;
                                                     mon("         JMP   $0809                   ; 0774: 7E 08 09      \n");
    PC = 0x0809;
    JUMP;
    
  case 0x0777:                                       mon("L0777    LDA   #$FF                    ; 0777: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$BD                    ; 0779: 97 BD         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xbd] = A;
                                                     mon("         LDD   #$7FD0                  ; 077B: CC 7F D0      \n");
    A = (UINT8)((0x7fd0) >> 8);
    B = (UINT8)((0x7fd0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBA  <$BA                    ; 077E: 90 BA         \n");
    res = A - memory_DP[0xba];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory_DP[0xba]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         PSHS  DP                      ; 0780: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         TFR   B,DP                    ; 0782: 1F 9B         \n");
    DP = (B) << 8;
    memory_DP = &memory[DP];
                                                     mon("         JSR   $0F88                   ; 0784: BD 0F 88      \n");
    memory[--S] = 0x0787 & 0xff; memory[--S] = 0x0787 >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x0787:                                       mon("L0787    JSR   [,X++]                  ; 0787: AD 91         \n");
    memory[--S] = 0x0789 & 0xff; memory[--S] = 0x0789 >> 8;
    PC = ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
    X = X + 2;
    JUMP;
  case 0x0789:                                       mon("L0789    JSR   $0F86                   ; 0789: BD 0F 86      \n");
    memory[--S] = 0x078c & 0xff; memory[--S] = 0x078c >> 8;
    PC = 0x0f86;
    JUMP;
  case 0x078C:                                       mon("L078C    LDD   #$A4FF                  ; 078C: CC A4 FF      \n");
    A = (UINT8)((0xa4ff) >> 8);
    B = (UINT8)((0xa4ff) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 078F: BD 0B 67      \n");
    memory[--S] = 0x0792 & 0xff; memory[--S] = 0x0792 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x0792:                                       mon("L0792    LDX   #$1B27                  ; 0792: 8E 1B 27      \n");
    X = 0x1b27;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #$C8B7                  ; 0795: CE C8 B7      \n");
    U = 0xc8b7;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         CLRA                          ; 0798: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   ,U+                     ; 0799: E6 C0         \n");
    B = (UINT8)memory[U];
 // N = B;
 // Z = B;
 // V = 0;
    U = U + 1;
                                                     mon("         JSR   Abs_b                   ; 079B: BD F5 8B      \n");
    memory[--S] = 0x079e & 0xff; memory[--S] = 0x079e >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x079E:                                       mon("L079E    PSHS  B,A                     ; 079E: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         CLRA                          ; 07A0: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   ,U+                     ; 07A1: E6 C0         \n");
    B = (UINT8)memory[U];
 // N = B;
 // Z = B;
 // V = 0;
    U = U + 1;
                                                     mon("         JSR   Abs_b                   ; 07A3: BD F5 8B      \n");
    memory[--S] = 0x07a6 & 0xff; memory[--S] = 0x07a6 >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x07A6:                                       mon("L07A6    ADDD  ,S                      ; 07A6: E3 E4         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[S]<<8)|memory[(UINT16)((S)+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[S]<<8)|memory[(UINT16)((S)+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   ,S                      ; 07A8: ED E4         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[S] = A;
    memory[S + 1] = B;
                                                     mon("         CLRA                          ; 07AA: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   ,U+                     ; 07AB: E6 C0         \n");
    B = (UINT8)memory[U];
 // N = B;
 // Z = B;
 // V = 0;
    U = U + 1;
                                                     mon("         JSR   Abs_b                   ; 07AD: BD F5 8B      \n");
    memory[--S] = 0x07b0 & 0xff; memory[--S] = 0x07b0 >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x07B0:                                       mon("L07B0    ADDD  ,S++                    ; 07B0: E3 E1         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[S]<<8)|memory[(UINT16)((S)+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[S]<<8)|memory[(UINT16)((S)+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         LSRA                          ; 07B2: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 07B3: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 07B4: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 07B5: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         STB   <$06                    ; 07B6: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
                                                     mon("         CMPB  #$03                    ; 07B8: C1 03         \n");
    res = B - (SINT8)0x03;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x03) & (B ^ (UINT8)res);
                                                     mon("         BHI   $07E5                   ; 07BA: 22 29         \n");
    if (Z && (!C)) {
    PC = 0x07e5;
    JUMP;
    }
                                                     mon("         CLR   $C8BB                   ; 07BC: 7F C8 BB      \n");
    memory[0xc8bb] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   $C8BC                   ; 07BF: 7F C8 BC      \n");
    memory[0xc8bc] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   $C8ED                   ; 07C2: FC C8 ED      \n");
    A = memory[0xc8ed];
    B = memory[(UINT16)((0xc8ed)+1)];
 // Z = A|B;
    N = A;
 // V = 0;
                                                     mon("         BPL   $07CA                   ; 07C5: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x07ca;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 07C7: BD 19 CB      \n");
    memory[--S] = 0x07ca & 0xff; memory[--S] = 0x07ca >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x07CA:                                       mon("L07CA    CMPD  #$0100                  ; 07CA: 10 83 01 00   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0100);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0100)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLE   $07DA                   ; 07CE: 2F 0A         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x07da;
    JUMP;
    }
                                                     mon("         LDA   $C8D0                   ; 07D0: B6 C8 D0      \n");
    A = (UINT8)memory[0xc8d0];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BNE   $07E5                   ; 07D3: 26 10         \n");
    if (Z) {
    PC = 0x07e5;
    JUMP;
    }
                                                     mon("         JSR   $0F91                   ; 07D5: BD 0F 91      \n");
    memory[--S] = 0x07d8 & 0xff; memory[--S] = 0x07d8 >> 8;
    PC = 0x0f91;
    JUMP;
  case 0x07D8:                                       mon("L07D8    BRA   $07E5                   ; 07D8: 20 0B         \n");
    PC = 0x07e5;
    JUMP;
    
  case 0x07DA:                                       mon("L07DA    LDA   $C8C7                   ; 07DA: B6 C8 C7      \n");
    A = (UINT8)memory[0xc8c7];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $07E5                   ; 07DD: 26 06         \n");
    if (Z) {
    PC = 0x07e5;
    JUMP;
    }
                                                     mon("         INC   $C8C7                   ; 07DF: 7C C8 C7      \n");
    res = (UINT8)(memory[0xc8c7] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory[0xc8c7]);
    memory[0xc8c7] = res;
                                                     mon("         JSR   $10B9                   ; 07E2: BD 10 B9      \n");
    memory[--S] = 0x07e5 & 0xff; memory[--S] = 0x07e5 >> 8;
    PC = 0x10b9;
    JUMP;
  case 0x07E5:                                       mon("L07E5    LDA   $C8C0                   ; 07E5: B6 C8 C0      \n");
    A = (UINT8)memory[0xc8c0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$60                    ; 07E8: 81 60         \n");
    res = A - (SINT8)0x60;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x60) & (A ^ (UINT8)res);
                                                     mon("         BCC   $0807                   ; 07EA: 24 1B         \n");
    if (!C) {
    PC = 0x0807;
    JUMP;
    }
                                                     mon("         CLR   Vec_0Ref_Enable         ; 07EC: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         JSR   $1525                   ; 07EF: BD 15 25      \n");
    memory[--S] = 0x07f2 & 0xff; memory[--S] = 0x07f2 >> 8;
    PC = 0x1525;
    JUMP;
  case 0x07F2:                                       mon("L07F2    DEC   Vec_0Ref_Enable         ; 07F2: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         LDD   $C8BB                   ; 07F5: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ASRA                          ; 07F8: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 07F9: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRB                          ; 07FA: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         ASRB                          ; 07FB: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         JSR   $0B67                   ; 07FC: BD 0B 67      \n");
    memory[--S] = 0x07ff & 0xff; memory[--S] = 0x07ff >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x07FF:                                       mon("L07FF    LDX   #$1B31                  ; 07FF: 8E 1B 31      \n");
    X = 0x1b31;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   #$1F                    ; 0802: C6 1F         \n");
    B = (UINT8)(SINT8)0x1f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   $16BC                   ; 0804: BD 16 BC      \n");
    memory[--S] = 0x0807 & 0xff; memory[--S] = 0x0807 >> 8;
    PC = 0x16bc;
    JUMP;
  case 0x0807:                                       mon("L0807    PULS  DP                      ; 0807: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
  case 0x0809:                                       mon("L0809    LDU   #$C9F0                  ; 0809: CE C9 F0      \n");
    U = 0xc9f0;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
  case 0x080C:                                       mon("L080C    LDA   $07,U                   ; 080C: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $084D                   ; 080E: 26 3D         \n");
    if (Z) {
    PC = 0x084d;
    JUMP;
    }
                                                     mon("         JSR   Random                  ; 0810: BD F5 17      \n");
    memory[--S] = 0x0813 & 0xff; memory[--S] = 0x0813 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0813:                                       mon("L0813    STA   $07,U                   ; 0813: A7 47         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0007)] = A;
                                                     mon("         ASRA                          ; 0815: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0816: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0817: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0818: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0819: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ADDA  <$86                    ; 081A: 9B 86         \n");
    res = A + memory_DP[0x86];
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory_DP[0x86] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0x86] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         STA   <$36                    ; 081C: 97 36         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x36] = A;
                                                     mon("         JSR   Get_Rise_Run            ; 081E: BD F5 EF      \n");
    memory[--S] = 0x0821 & 0xff; memory[--S] = 0x0821 >> 8;
    PC = 0xf5ef;
    JUMP;
  case 0x0821:                                       mon("L0821    LDA   $07,U                   ; 0821: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $0826                   ; 0823: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0826;
    JUMP;
    }
                                                     mon("         NEGA                          ; 0825: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x0826:                                       mon("L0826    LDB   <$ED                    ; 0826: D6 ED         \n");
    B = (UINT8)memory_DP[0xed];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BPL   $082B                   ; 0828: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x082b;
    JUMP;
    }
                                                     mon("         NEGA                          ; 082A: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x082B:                                       mon("L082B    PSHS  A                       ; 082B: 34 02         \n");
    memory[--S] = A;
                                                     mon("         JSR   Xform_Rise_a            ; 082D: BD F6 61      \n");
    memory[--S] = 0x0830 & 0xff; memory[--S] = 0x0830 >> 8;
    PC = 0xf661;
    JUMP;
  case 0x0830:                                       mon("L0830    NEGA                          ; 0830: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
                                                     mon("         TFR   A,B                     ; 0831: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 0833: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$80                    ; 0834: D3 80         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x80]<<8)|memory_DP[0x80 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 0836: ED 40         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         PULS  A                       ; 0838: 35 02         \n");
    A = memory[S++];
                                                     mon("         JSR   Xform_Run_a             ; 083A: BD F6 5B      \n");
    memory[--S] = 0x083d & 0xff; memory[--S] = 0x083d >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x083D:                                       mon("L083D    TFR   A,B                     ; 083D: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 083F: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$84                    ; 0840: D3 84         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x84]<<8)|memory_DP[0x84 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 0842: ED 44         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         LDD   <$82                    ; 0844: DC 82         \n");
    A = memory_DP[0x82];
    B = memory_DP[0x82 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  #$0E                    ; 0846: 83 00 0E      \n");
    arg = (A << 8) | B;
    res = arg - (0x000e);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x000e)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 0849: ED 42         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
                                                     mon("         CLR   $06,U                   ; 084B: 6F 46         \n");
    memory[(UINT16)(U + 0x0006)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x084D:                                       mon("L084D    LDD   <$ED                    ; 084D: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
    N = A;
 // V = 0;
                                                     mon("         BPL   $0858                   ; 084F: 2A 07         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0858;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0851: BD 19 CB      \n");
    memory[--S] = 0x0854 & 0xff; memory[--S] = 0x0854 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0854:                                       mon("L0854    ASRA                          ; 0854: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0855: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 0856: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0857: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
  case 0x0858:                                       mon("L0858    ASRA                          ; 0858: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0859: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 085A: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 085B: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         CMPD  #$D0                    ; 085C: 10 83 00 D0   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x00d0);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x00d0)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BCC   $0865                   ; 0860: 24 03         \n");
    if (!C) {
    PC = 0x0865;
    JUMP;
    }
                                                     mon("         LDD   #$E0                    ; 0862: CC 00 E0      \n");
    A = (UINT8)((0x00e0) >> 8);
    B = (UINT8)((0x00e0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x0865:                                       mon("L0865    STD   <$97                    ; 0865: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDB   $06,U                   ; 0867: E6 46         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0006)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   $03,U                   ; 0869: A6 43         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0003)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ADDD  <$97                    ; 086B: D3 97         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x97]<<8)|memory_DP[0x97 + 1]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x97]<<8)|memory_DP[0x97 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   $06,U                   ; 086D: E7 46         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x0006)] = B;
                                                     mon("         STA   $03,U                   ; 086F: A7 43         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0003)] = A;
                                                     mon("         LDA   $02,U                   ; 0871: A6 42         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0002)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ADCA  #$00                    ; 0873: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         STA   $02,U                   ; 0875: A7 42         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
                                                     mon("         DEC   $07,U                   ; 0877: 6A 47         \n");
    res = (UINT8)(memory[(UINT16)(U + 0x0007)] - 1);
 // N = res;
 // Z = res;
 // V = memory[(UINT16)(U + 0x0007)] & ~res;
    memory[(UINT16)(U + 0x0007)] = res;
                                                     mon("         LDX   #$1B6E                  ; 0879: 8E 1B 6E      \n");
    X = 0x1b6e;
    Z = X;
    N = (X) >> 8;
    V = 0;
                                                     mon("         JSR   $11D9                   ; 087C: BD 11 D9      \n");
    memory[--S] = 0x087f & 0xff; memory[--S] = 0x087f >> 8;
    PC = 0x11d9;
    JUMP;
  case 0x087F:                                       mon("L087F    TFR   CC,B                    ; 087F: 1F A9         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    B = CC;
                                                     mon("         BVS   $088B                   ; 0881: 29 08         \n");
    if ((SINT8)V <  0) {
    PC = 0x088b;
    JUMP;
    }
                                                     mon("         BCS   $0895                   ; 0883: 25 10         \n");
    if (C) {
    PC = 0x0895;
    JUMP;
    }
                                                     mon("         LDA   <$ED                    ; 0885: 96 ED         \n");
    A = (UINT8)memory_DP[0xed];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BMI   $0893                   ; 0887: 2B 0A         \n");
    if ((SINT8)N <  0) {
    PC = 0x0893;
    JUMP;
    }
                                                     mon("         BRA   $0895                   ; 0889: 20 0A         \n");
    PC = 0x0895;
    JUMP;
    
  case 0x088B:                                       mon("L088B    LDA   <$ED                    ; 088B: 96 ED         \n");
    A = (UINT8)memory_DP[0xed];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $0893                   ; 088D: 2A 04         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0893;
    JUMP;
    }
                                                     mon("         TFR   B,CC                    ; 088F: 1F 9A         \n");
    CC = B;
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         BCS   $0895                   ; 0891: 25 02         \n");
    if (C) {
    PC = 0x0895;
    JUMP;
    }
  case 0x0893:                                       mon("L0893    CLR   $07,U                   ; 0893: 6F 47         \n");
    memory[(UINT16)(U + 0x0007)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0895:                                       mon("L0895    LEAU  $08,U                   ; 0895: 33 48         \n");
    U = (U + 0x0008);
                                                     mon("         CMPU  #$CA28                  ; 0897: 11 83 CA 28   \n");
    res = (U) - (0xca28);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = (((U) ^ (0xca28)) & ((U) ^ res)) >> 8;
                                                     mon("         LBCS  $080C                   ; 089B: 10 25 FF 6D   \n");
    if (C) {
    PC = 0x080c;
    JUMP;
    }
  case 0x089F:                                       mon("L089F    JSR   Wait_Recal              ; 089F: BD F1 92      \n");
    memory[--S] = 0x08a2 & 0xff; memory[--S] = 0x08a2 >> 8;
    PC = 0xf192;
    JUMP;
  case 0x08A2:                                       mon("L08A2    JSR   Read_Btns               ; 08A2: BD F1 BA      \n");
    memory[--S] = 0x08a5 & 0xff; memory[--S] = 0x08a5 >> 8;
    PC = 0xf1ba;
    JUMP;
  case 0x08A5:                                       mon("L08A5    JSR   Joy_Digital             ; 08A5: BD F1 F8      \n");
    memory[--S] = 0x08a8 & 0xff; memory[--S] = 0x08a8 >> 8;
    PC = 0xf1f8;
    JUMP;
  case 0x08A8:                                       mon("L08A8    JSR   Intensity_7F            ; 08A8: BD F2 A9      \n");
    memory[--S] = 0x08ab & 0xff; memory[--S] = 0x08ab >> 8;
    PC = 0xf2a9;
    JUMP;
  case 0x08AB:                                       mon("L08AB    LDD   #$AC80                  ; 08AB: CC AC 80      \n");
    A = (UINT8)((0xac80) >> 8);
    B = (UINT8)((0xac80) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 08AE: BD 0B 67      \n");
    memory[--S] = 0x08b1 & 0xff; memory[--S] = 0x08b1 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x08B1:                                       mon("L08B1    LDD   #$FF10                  ; 08B1: CC FF 10      \n");
    A = (UINT8)((0xff10) >> 8);
    B = (UINT8)((0xff10) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 08B4: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         STB   Vec_Pattern             ; 08B6: F7 C8 29      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc829] = B;
                                                     mon("         LDX   #$1AFB                  ; 08B9: 8E 1A FB      \n");
    X = 0x1afb;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   Draw_VL_mode            ; 08BC: BD F4 6E      \n");
    memory[--S] = 0x08bf & 0xff; memory[--S] = 0x08bf >> 8;
    PC = 0xf46e;
    JUMP;
  case 0x08BF:                                       mon("L08BF    PSHS  DP                      ; 08BF: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_C8                ; 08C1: BD F1 AF      \n");
    memory[--S] = 0x08c4 & 0xff; memory[--S] = 0x08c4 >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x08C4:                                       mon("L08C4    LDA   <$C0                    ; 08C4: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$60                    ; 08C6: 81 60         \n");
    res = A - (SINT8)0x60;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x60) & (A ^ (UINT8)res);
                                                     mon("         BCC   $0910                   ; 08C8: 24 46         \n");
    if (!C) {
    PC = 0x0910;
    JUMP;
    }
                                                     mon("         LDA   <$BD                    ; 08CA: 96 BD         \n");
    A = (UINT8)memory_DP[0xbd];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BMI   $0902                   ; 08CC: 2B 34         \n");
    if ((SINT8)N <  0) {
    PC = 0x0902;
    JUMP;
    }
                                                     mon("         LDA   #$7F                    ; 08CE: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$26                    ; 08D0: D6 26         \n");
    B = (UINT8)memory_DP[0x26];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Rise_Run_Y              ; 08D2: BD F6 01      \n");
    memory[--S] = 0x08d5 & 0xff; memory[--S] = 0x08d5 >> 8;
    PC = 0xf601;
    JUMP;
  case 0x08D5:                                       mon("L08D5    CLR   <$24                    ; 08D5: 0F 24         \n");
    memory_DP[0x24] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         PULS  DP                      ; 08D7: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         PSHS  B,A                     ; 08D9: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   #$A800                  ; 08DB: CC A8 00      \n");
    A = (UINT8)((0xa800) >> 8);
    B = (UINT8)((0xa800) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 08DE: BD 0B 67      \n");
    memory[--S] = 0x08e1 & 0xff; memory[--S] = 0x08e1 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x08E1:                                       mon("L08E1    LDD   #$1599                  ; 08E1: CC 15 99      \n");
    A = (UINT8)((0x1599) >> 8);
    B = (UINT8)((0x1599) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 08E4: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         STB   Vec_Pattern             ; 08E6: F7 C8 29      \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[0xc829] = B;
                                                     mon("         JSR   $0F82                   ; 08E9: BD 0F 82      \n");
    memory[--S] = 0x08ec & 0xff; memory[--S] = 0x08ec >> 8;
    PC = 0x0f82;
    JUMP;
  case 0x08EC:                                       mon("L08EC    LDX   #$1B1D                  ; 08EC: 8E 1B 1D      \n");
    X = 0x1b1d;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   Draw_VL_mode            ; 08EF: BD F4 6E      \n");
    memory[--S] = 0x08f2 & 0xff; memory[--S] = 0x08f2 >> 8;
    PC = 0xf46e;
    JUMP;
  case 0x08F2:                                       mon("L08F2    DEC   Vec_0Ref_Enable         ; 08F2: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         JSR   $0F86                   ; 08F5: BD 0F 86      \n");
    memory[--S] = 0x08f8 & 0xff; memory[--S] = 0x08f8 >> 8;
    PC = 0x0f86;
    JUMP;
  case 0x08F8:                                       mon("L08F8    PULS  A,B                     ; 08F8: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         JSR   Draw_Line_d             ; 08FA: BD F3 DF      \n");
    memory[--S] = 0x08fd & 0xff; memory[--S] = 0x08fd >> 8;
    PC = 0xf3df;
    JUMP;
  case 0x08FD:                                       mon("L08FD    PSHS  DP                      ; 08FD: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_C8                ; 08FF: BD F1 AF      \n");
    memory[--S] = 0x0902 & 0xff; memory[--S] = 0x0902 >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x0902:                                       mon("L0902    LDA   <$EC                    ; 0902: 96 EC         \n");
    A = (UINT8)memory_DP[0xec];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$D0                    ; 0904: 9A D0         \n");
    A = A | memory_DP[0xd0];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$C5                    ; 0906: 9A C5         \n");
    A = A | memory_DP[0xc5];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$D2                    ; 0908: 9A D2         \n");
    A = A | memory_DP[0xd2];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$BE                    ; 090A: 9A BE         \n");
    A = A | memory_DP[0xbe];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$CE                    ; 090C: 9A CE         \n");
    A = A | memory_DP[0xce];
    Z = A;
    N = A;
    V = 0;
                                                     mon("         BEQ   $0915                   ; 090E: 27 05         \n");
    if (!Z) {
    PC = 0x0915;
    JUMP;
    }
  case 0x0910:                                       mon("L0910    PULS  DP                      ; 0910: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         JMP   $0994                   ; 0912: 7E 09 94      \n");
    PC = 0x0994;
    JUMP;
    
  case 0x0915:                                       mon("L0915    LDB   #$3F                    ; 0915: C6 3F         \n");
    B = (UINT8)(SINT8)0x3f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   <$C4                    ; 0917: 96 C4         \n");
    A = (UINT8)memory_DP[0xc4];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $091D                   ; 0919: 26 02         \n");
    if (Z) {
    PC = 0x091d;
    JUMP;
    }
                                                     mon("         LDB   #$7F                    ; 091B: C6 7F         \n");
    B = (UINT8)(SINT8)0x7f;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x091D:                                       mon("L091D    PSHS  B                       ; 091D: 34 04         \n");
    memory[--S] = B;
                                                     mon("         LDD   <$91                    ; 091F: DC 91         \n");
    A = memory_DP[0x91];
    B = memory_DP[0x91 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 0921: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         TFR   D,Y                     ; 0923: 1F 02         \n");
    Y = ((A << 8) | B);
                                                     mon("         BPL   $092A                   ; 0925: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x092a;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0927: BD 19 CB      \n");
    memory[--S] = 0x092a & 0xff; memory[--S] = 0x092a >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x092A:                                       mon("L092A    STD   <$97                    ; 092A: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDD   <$95                    ; 092C: DC 95         \n");
    A = memory_DP[0x95];
    B = memory_DP[0x95 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 092E: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         PSHS  B,A                     ; 0930: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         BPL   $0937                   ; 0932: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0937;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0934: BD 19 CB      \n");
    memory[--S] = 0x0937 & 0xff; memory[--S] = 0x0937 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0937:                                       mon("L0937    ADDD  <$97                    ; 0937: D3 97         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x97]<<8)|memory_DP[0x97 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x97]<<8)|memory_DP[0x97 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$97                    ; 0939: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         PULS  A,B                     ; 093B: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         JSR   $1751                   ; 093D: BD 17 51      \n");
    memory[--S] = 0x0940 & 0xff; memory[--S] = 0x0940 >> 8;
    PC = 0x1751;
    JUMP;
  case 0x0940:                                       mon("L0940    SUBB  <$86                    ; 0940: D0 86         \n");
    res = B - memory_DP[0x86];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0x86]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ADDB  #$10                    ; 0942: CB 10         \n");
    res = B + (SINT8)0x10;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = B ^ (SINT8)0x10 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         CMPB  <$C2                    ; 0944: D1 C2         \n");
    res = B - memory_DP[0xc2];
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ memory_DP[0xc2]) & (B ^ (UINT8)res);
                                                     mon("         BEQ   $095B                   ; 0946: 27 13         \n");
    if (!Z) {
    PC = 0x095b;
    JUMP;
    }
                                                     mon("         STB   <$C2                    ; 0948: D7 C2         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xc2] = B;
                                                     mon("         STB   <$36                    ; 094A: D7 36         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x36] = B;
                                                     mon("         LDX   #$1B3B                  ; 094C: 8E 1B 3B      \n");
    X = 0x1b3b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #$CA9B                  ; 094F: CE CA 9B      \n");
    U = 0xca9b;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDD   ,X++                    ; 0952: EC 81         \n");
    A = memory[X];
    B = memory[(UINT16)((X)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    X = X + 2;
                                                     mon("         STD   ,U++                    ; 0954: ED C1         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[U] = A;
    memory[U + 1] = B;
    U = U + 2;
                                                     mon("         STA   <$23                    ; 0956: 97 23         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x23] = A;
                                                     mon("         JSR   Rot_VL                  ; 0958: BD F6 16      \n");
    memory[--S] = 0x095b & 0xff; memory[--S] = 0x095b >> 8;
    PC = 0xf616;
    JUMP;
  case 0x095B:                                       mon("L095B    DEC   <$C3                    ; 095B: 0A C3         \n");
    res = (UINT8)(memory_DP[0xc3] - 1);
 // N = res;
    Z = res;
 // V = memory_DP[0xc3] & ~res;
    memory_DP[0xc3] = res;
                                                     mon("         BNE   $097B                   ; 095D: 26 1C         \n");
    if (Z) {
    PC = 0x097b;
    JUMP;
    }
                                                     mon("         COM   <$C4                    ; 095F: 03 C4         \n");
    memory_DP[0xc4] = memory_DP[0xc4] ^ 0xff;
    Z = memory_DP[0xc4];
 // N = memory_DP[0xc4];
 // V = 0;
 // C = 256;
                                                     mon("         BEQ   $0977                   ; 0961: 27 14         \n");
    if (!Z) {
    PC = 0x0977;
    JUMP;
    }
                                                     mon("         DEC   <$D5                    ; 0963: 0A D5         \n");
    res = (UINT8)(memory_DP[0xd5] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd5] & ~res;
    memory_DP[0xd5] = res;
                                                     mon("         LDD   <$97                    ; 0965: DC 97         \n");
    A = memory_DP[0x97];
    B = memory_DP[0x97 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         LSRA                          ; 0967: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 0968: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 0969: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 096A: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 096B: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 096C: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 096D: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 096E: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 096F: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 0970: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRA                          ; 0971: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         RORB                          ; 0972: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         CMPB  #$04                    ; 0973: C1 04         \n");
    res = B - (SINT8)0x04;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
                                                     mon("         BCC   $0979                   ; 0975: 24 02         \n");
    if (!C) {
    PC = 0x0979;
    JUMP;
    }
  case 0x0977:                                       mon("L0977    LDB   #$04                    ; 0977: C6 04         \n");
    B = (UINT8)(SINT8)0x04;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x0979:                                       mon("L0979    STB   <$C3                    ; 0979: D7 C3         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xc3] = B;
  case 0x097B:                                       mon("L097B    LDB   <$C0                    ; 097B: D6 C0         \n");
    B = (UINT8)memory_DP[0xc0];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         PULS  A,DP                    ; 097D: 35 0A         \n");
    A = memory[S++];
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         CMPB  #$50                    ; 097F: C1 50         \n");
    res = B - (SINT8)0x50;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x50) & (B ^ (UINT8)res);
                                                     mon("         BCC   $0994                   ; 0981: 24 11         \n");
    if (!C) {
    PC = 0x0994;
    JUMP;
    }
                                                     mon("         JSR   $0F88                   ; 0983: BD 0F 88      \n");
    memory[--S] = 0x0986 & 0xff; memory[--S] = 0x0986 >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x0986:                                       mon("L0986    LDD   #$A800                  ; 0986: CC A8 00      \n");
    A = (UINT8)((0xa800) >> 8);
    B = (UINT8)((0xa800) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 0989: BD 0B 67      \n");
    memory[--S] = 0x098c & 0xff; memory[--S] = 0x098c >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x098C:                                       mon("L098C    LDB   #$15                    ; 098C: C6 15         \n");
    B = (UINT8)(SINT8)0x15;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDX   #$CA9B                  ; 098E: 8E CA 9B      \n");
    X = 0xca9b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $16BC                   ; 0991: BD 16 BC      \n");
    memory[--S] = 0x0994 & 0xff; memory[--S] = 0x0994 >> 8;
    PC = 0x16bc;
    JUMP;
  case 0x0994:                                       mon("L0994    JSR   $0F86                   ; 0994: BD 0F 86      \n");
    memory[--S] = 0x0997 & 0xff; memory[--S] = 0x0997 >> 8;
    PC = 0x0f86;
    JUMP;
  case 0x0997:                                       mon("L0997    CLR   Vec_0Ref_Enable         ; 0997: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   #$B5CF                  ; 099A: CC B5 CF      \n");
    A = (UINT8)((0xb5cf) >> 8);
    B = (UINT8)((0xb5cf) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 099D: BD 0B 67      \n");
    memory[--S] = 0x09a0 & 0xff; memory[--S] = 0x09a0 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x09A0:                                       mon("L09A0    LDA   #$18                    ; 09A0: 86 18         \n");
    A = (UINT8)(SINT8)0x18;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 09A2: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDU   #$C8C1                  ; 09A4: CE C8 C1      \n");
    U = 0xc8c1;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1714                   ; 09A7: BD 17 14      \n");
    memory[--S] = 0x09aa & 0xff; memory[--S] = 0x09aa >> 8;
    PC = 0x1714;
    JUMP;
  case 0x09AA:                                       mon("L09AA    LDD   #$41                    ; 09AA: CC 00 41      \n");
    A = (UINT8)((0x0041) >> 8);
    B = (UINT8)((0x0041) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 09AD: BD F2 FC      \n");
    memory[--S] = 0x09b0 & 0xff; memory[--S] = 0x09b0 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x09B0:                                       mon("L09B0    DEC   Vec_0Ref_Enable         ; 09B0: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         LDA   #$18                    ; 09B3: 86 18         \n");
    A = (UINT8)(SINT8)0x18;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 09B5: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDU   #$C8C0                  ; 09B7: CE C8 C0      \n");
    U = 0xc8c0;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1714                   ; 09BA: BD 17 14      \n");
    memory[--S] = 0x09bd & 0xff; memory[--S] = 0x09bd >> 8;
    PC = 0x1714;
    JUMP;
  case 0x09BD:                                       mon("L09BD    JSR   Intensity_7F            ; 09BD: BD F2 A9      \n");
    memory[--S] = 0x09c0 & 0xff; memory[--S] = 0x09c0 >> 8;
    PC = 0xf2a9;
    JUMP;
  case 0x09C0:                                       mon("L09C0    CLR   Vec_0Ref_Enable         ; 09C0: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   #$A29E                  ; 09C3: CC A2 9E      \n");
    A = (UINT8)((0xa29e) >> 8);
    B = (UINT8)((0xa29e) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 09C6: BD 0B 67      \n");
    memory[--S] = 0x09c9 & 0xff; memory[--S] = 0x09c9 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x09C9:                                       mon("L09C9    LDX   #$1B4B                  ; 09C9: 8E 1B 4B      \n");
    X = 0x1b4b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   Draw_VLcs               ; 09CC: BD F3 D6      \n");
    memory[--S] = 0x09cf & 0xff; memory[--S] = 0x09cf >> 8;
    PC = 0xf3d6;
    JUMP;
  case 0x09CF:                                       mon("L09CF    LDB   $C8EF                   ; 09CF: F6 C8 EF      \n");
    B = (UINT8)memory[0xc8ef];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LSRB                          ; 09D2: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 09D3: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         JSR   Mov_Draw_VL_b           ; 09D4: BD F3 B1      \n");
    memory[--S] = 0x09d7 & 0xff; memory[--S] = 0x09d7 >> 8;
    PC = 0xf3b1;
    JUMP;
  case 0x09D7:                                       mon("L09D7    DEC   Vec_0Ref_Enable         ; 09D7: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         JSR   Mov_Draw_VLcs           ; 09DA: BD F3 B5      \n");
    memory[--S] = 0x09dd & 0xff; memory[--S] = 0x09dd >> 8;
    PC = 0xf3b5;
    JUMP;
  case 0x09DD:                                       mon("L09DD    CLR   Vec_0Ref_Enable         ; 09DD: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   #$A220                  ; 09E0: CC A2 20      \n");
    A = (UINT8)((0xa220) >> 8);
    B = (UINT8)((0xa220) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $0B67                   ; 09E3: BD 0B 67      \n");
    memory[--S] = 0x09e6 & 0xff; memory[--S] = 0x09e6 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x09E6:                                       mon("L09E6    LDX   #$1B4B                  ; 09E6: 8E 1B 4B      \n");
    X = 0x1b4b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   Draw_VLcs               ; 09E9: BD F3 D6      \n");
    memory[--S] = 0x09ec & 0xff; memory[--S] = 0x09ec >> 8;
    PC = 0xf3d6;
    JUMP;
  case 0x09EC:                                       mon("L09EC    LDD   $C8ED                   ; 09EC: FC C8 ED      \n");
    A = memory[0xc8ed];
    B = memory[(UINT16)((0xc8ed)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ADDD  #$0700                  ; 09EF: C3 07 00      \n");
    arg = (A << 8) | B;
    res = arg + 0x0700;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0700) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$0E00                  ; 09F2: 10 83 0E 00   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0e00);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0e00)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLE   $09FB                   ; 09F6: 2F 03         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x09fb;
    JUMP;
    }
                                                     mon("         LDD   #$0E00                  ; 09F8: CC 0E 00      \n");
    A = (UINT8)((0x0e00) >> 8);
    B = (UINT8)((0x0e00) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x09FB:                                       mon("L09FB    ASRA                          ; 09FB: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 09FC: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 09FD: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 09FE: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 09FF: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0A00: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 0A01: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0A02: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         LSRB                          ; 0A03: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0A04: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         INCB                          ; 0A05: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
                                                     mon("         JSR   Mov_Draw_VL_b           ; 0A06: BD F3 B1      \n");
    memory[--S] = 0x0a09 & 0xff; memory[--S] = 0x0a09 >> 8;
    PC = 0xf3b1;
    JUMP;
  case 0x0A09:                                       mon("L0A09    DEC   Vec_0Ref_Enable         ; 0A09: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         JSR   Mov_Draw_VLcs           ; 0A0C: BD F3 B5      \n");
    memory[--S] = 0x0a0f & 0xff; memory[--S] = 0x0a0f >> 8;
    PC = 0xf3b5;
    JUMP;
  case 0x0A0F:                                       mon("L0A0F    LDA   #$84                    ; 0A0F: 86 84         \n");
    A = (UINT8)(SINT8)0x84;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 0A11: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDA   $C8D2                   ; 0A13: B6 C8 D2      \n");
    A = (UINT8)memory[0xc8d2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0A29                   ; 0A16: 26 11         \n");
    if (Z) {
    PC = 0x0a29;
    JUMP;
    }
                                                     mon("         LDA   $C8C5                   ; 0A18: B6 C8 C5      \n");
    A = (UINT8)memory[0xc8c5];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0A29                   ; 0A1B: 27 0C         \n");
    if (!Z) {
    PC = 0x0a29;
    JUMP;
    }
                                                     mon("         LSRA                          ; 0A1D: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         PSHS  A                       ; 0A1E: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   #$7F                    ; 0A20: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 0A22: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         JSR   Intensity_a             ; 0A24: BD F2 AB      \n");
    memory[--S] = 0x0a27 & 0xff; memory[--S] = 0x0a27 >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x0A27:                                       mon("L0A27    BRA   $0A37                   ; 0A27: 20 0E         \n");
    PC = 0x0a37;
    JUMP;
    
  case 0x0A29:                                       mon("L0A29    JSR   Intensity_7F            ; 0A29: BD F2 A9      \n");
    memory[--S] = 0x0a2c & 0xff; memory[--S] = 0x0a2c >> 8;
    PC = 0xf2a9;
    JUMP;
  case 0x0A2C:                                       mon("L0A2C    LDA   $C8EC                   ; 0A2C: B6 C8 EC      \n");
    A = (UINT8)memory[0xc8ec];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   $C8D2                   ; 0A2F: BA C8 D2      \n");
    A = A | memory[0xc8d2];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   $C8D0                   ; 0A32: BA C8 D0      \n");
    A = A | memory[0xc8d0];
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $0A67                   ; 0A35: 27 30         \n");
    if (!Z) {
    PC = 0x0a67;
    JUMP;
    }
  case 0x0A37:                                       mon("L0A37    LDD   #$FA28                  ; 0A37: CC FA 28      \n");
    A = (UINT8)((0xfa28) >> 8);
    B = (UINT8)((0xfa28) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   Vec_Text_HW             ; 0A3A: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
                                                     mon("         LDD   #$0207                  ; 0A3D: CC 02 07      \n");
    A = (UINT8)((0x0207) >> 8);
    B = (UINT8)((0x0207) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         LDX   #$1F8B                  ; 0A40: 8E 1F 8B      \n");
    X = 0x1f8b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $0FFF                   ; 0A43: BD 0F FF      \n");
    memory[--S] = 0x0a46 & 0xff; memory[--S] = 0x0a46 >> 8;
    PC = 0x0fff;
    JUMP;
  case 0x0A46:                                       mon("L0A46    LDU   #$CA63                  ; 0A46: CE CA 63      \n");
    U = 0xca63;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1018                   ; 0A49: BD 10 18      \n");
    memory[--S] = 0x0a4c & 0xff; memory[--S] = 0x0a4c >> 8;
    PC = 0x1018;
    JUMP;
  case 0x0A4C:                                       mon("L0A4C    JSR   $0FF9                   ; 0A4C: BD 0F F9      \n");
    memory[--S] = 0x0a4f & 0xff; memory[--S] = 0x0a4f >> 8;
    PC = 0x0ff9;
    JUMP;
  case 0x0A4F:                                       mon("L0A4F    LDA   Vec_Num_Players         ; 0A4F: B6 C8 79      \n");
    A = (UINT8)memory[0xc879];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0A67                   ; 0A52: 27 13         \n");
    if (!Z) {
    PC = 0x0a67;
    JUMP;
    }
                                                     mon("         LDD   #$FC30                  ; 0A54: CC FC 30      \n");
    A = (UINT8)((0xfc30) >> 8);
    B = (UINT8)((0xfc30) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   Vec_Text_HW             ; 0A57: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
                                                     mon("         LDA   $C8E1                   ; 0A5A: B6 C8 E1      \n");
    A = (UINT8)memory[0xc8e1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDU   #$1AC0                  ; 0A5D: CE 1A C0      \n");
    U = 0x1ac0;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         EORA  #$02                    ; 0A60: 88 02         \n");
    A = A ^ (SINT8)0x02;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         LDU   A,U                     ; 0A62: EE C6         \n");
    U = ((memory[(UINT16)(U + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(U + (SINT8)A))+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1018                   ; 0A64: BD 10 18      \n");
    memory[--S] = 0x0a67 & 0xff; memory[--S] = 0x0a67 >> 8;
    PC = 0x1018;
    JUMP;
  case 0x0A67:                                       mon("L0A67    JSR   Intensity_7F            ; 0A67: BD F2 A9      \n");
    memory[--S] = 0x0a6a & 0xff; memory[--S] = 0x0a6a >> 8;
    PC = 0xf2a9;
    JUMP;
  case 0x0A6A:                                       mon("L0A6A    LDD   #$FC30                  ; 0A6A: CC FC 30      \n");
    A = (UINT8)((0xfc30) >> 8);
    B = (UINT8)((0xfc30) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   Vec_Text_HW             ; 0A6D: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
                                                     mon("         LDA   $C8E1                   ; 0A70: B6 C8 E1      \n");
    A = (UINT8)memory[0xc8e1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDU   #$1AC0                  ; 0A73: CE 1A C0      \n");
    U = 0x1ac0;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDU   A,U                     ; 0A76: EE C6         \n");
    U = ((memory[(UINT16)(U + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(U + (SINT8)A))+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1018                   ; 0A78: BD 10 18      \n");
    memory[--S] = 0x0a7b & 0xff; memory[--S] = 0x0a7b >> 8;
    PC = 0x1018;
    JUMP;
  case 0x0A7B:                                       mon("L0A7B    LDA   $C8EC                   ; 0A7B: B6 C8 EC      \n");
    A = (UINT8)memory[0xc8ec];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0AA8                   ; 0A7E: 27 28         \n");
    if (!Z) {
    PC = 0x0aa8;
    JUMP;
    }
                                                     mon("         CLR   $C8D2                   ; 0A80: 7F C8 D2      \n");
    memory[0xc8d2] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         LDU   #$EE2F                  ; 0A83: CE EE 2F      \n");
    U = 0xee2f;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1013                   ; 0A86: BD 10 13      \n");
    memory[--S] = 0x0a89 & 0xff; memory[--S] = 0x0a89 >> 8;
    PC = 0x1013;
    JUMP;
  case 0x0A89:                                       mon("L0A89    ORA   $CA50                   ; 0A89: BA CA 50      \n");
    A = A | memory[0xca50];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $CA50                   ; 0A8C: B7 CA 50      \n");
    Z = A;
 // N = A;
 // V = 0;
    memory[0xca50] = A;
                                                     mon("         BEQ   $0A97                   ; 0A8F: 27 06         \n");
    if (!Z) {
    PC = 0x0a97;
    JUMP;
    }
                                                     mon("         LDU   #$1AAD                  ; 0A91: CE 1A AD      \n");
    U = 0x1aad;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1013                   ; 0A94: BD 10 13      \n");
    memory[--S] = 0x0a97 & 0xff; memory[--S] = 0x0a97 >> 8;
    PC = 0x1013;
    JUMP;
  case 0x0A97:                                       mon("L0A97    LDA   $C8D0                   ; 0A97: B6 C8 D0      \n");
    A = (UINT8)memory[0xc8d0];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0AE5                   ; 0A9A: 26 49         \n");
    if (Z) {
    PC = 0x0ae5;
    JUMP;
    }
                                                     mon("         LDA   $C826                   ; 0A9C: B6 C8 26      \n");
    A = (UINT8)memory[0xc826];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  #$10                    ; 0A9F: 85 10         \n");
    res = A & (SINT8)0x10;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0AE5                   ; 0AA1: 27 42         \n");
    if (!Z) {
    PC = 0x0ae5;
    JUMP;
    }
                                                     mon("         LDU   #$1A9C                  ; 0AA3: CE 1A 9C      \n");
    U = 0x1a9c;
    Z = U;
    N = (U) >> 8;
    V = 0;
                                                     mon("         BRA   $0ABA                   ; 0AA6: 20 12         \n");
    PC = 0x0aba;
    JUMP;
    
  case 0x0AA8:                                       mon("L0AA8    LDA   $C8D2                   ; 0AA8: B6 C8 D2      \n");
    A = (UINT8)memory[0xc8d2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0AB2                   ; 0AAB: 27 05         \n");
    if (!Z) {
    PC = 0x0ab2;
    JUMP;
    }
                                                     mon("         LDU   #$1A94                  ; 0AAD: CE 1A 94      \n");
    U = 0x1a94;
    Z = U;
    N = (U) >> 8;
    V = 0;
                                                     mon("         BRA   $0ABA                   ; 0AB0: 20 08         \n");
    PC = 0x0aba;
    JUMP;
    
  case 0x0AB2:                                       mon("L0AB2    LDA   $C8D0                   ; 0AB2: B6 C8 D0      \n");
    A = (UINT8)memory[0xc8d0];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0AC3                   ; 0AB5: 27 0C         \n");
    if (!Z) {
    PC = 0x0ac3;
    JUMP;
    }
                                                     mon("         LDU   #$1A80                  ; 0AB7: CE 1A 80      \n");
    U = 0x1a80;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
  case 0x0ABA:                                       mon("L0ABA    LDD   #$FA28                  ; 0ABA: CC FA 28      \n");
    A = (UINT8)((0xfa28) >> 8);
    B = (UINT8)((0xfa28) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   Vec_Text_HW             ; 0ABD: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
                                                     mon("         JSR   $1018                   ; 0AC0: BD 10 18      \n");
    memory[--S] = 0x0ac3 & 0xff; memory[--S] = 0x0ac3 >> 8;
    PC = 0x1018;
    JUMP;
  case 0x0AC3:                                       mon("L0AC3    LDA   $C8EC                   ; 0AC3: B6 C8 EC      \n");
    A = (UINT8)memory[0xc8ec];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0AE5                   ; 0AC6: 26 1D         \n");
    if (Z) {
    PC = 0x0ae5;
    JUMP;
    }
                                                     mon("         LDA   $C826                   ; 0AC8: B6 C8 26      \n");
    A = (UINT8)memory[0xc826];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  #$06                    ; 0ACB: 85 06         \n");
    res = A & (SINT8)0x06;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0AE5                   ; 0ACD: 27 16         \n");
    if (!Z) {
    PC = 0x0ae5;
    JUMP;
    }
                                                     mon("         LDA   $C8BD                   ; 0ACF: B6 C8 BD      \n");
    A = (UINT8)memory[0xc8bd];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $0ADA                   ; 0AD2: 2A 06         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0ada;
    JUMP;
    }
                                                     mon("         LDU   #$1A46                  ; 0AD4: CE 1A 46      \n");
    U = 0x1a46;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1026                   ; 0AD7: BD 10 26      \n");
    memory[--S] = 0x0ada & 0xff; memory[--S] = 0x0ada >> 8;
    PC = 0x1026;
    JUMP;
  case 0x0ADA:                                       mon("L0ADA    LDA   $C8BE                   ; 0ADA: B6 C8 BE      \n");
    A = (UINT8)memory[0xc8be];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0AE5                   ; 0ADD: 27 06         \n");
    if (!Z) {
    PC = 0x0ae5;
    JUMP;
    }
                                                     mon("         LDU   #$1A35                  ; 0ADF: CE 1A 35      \n");
    U = 0x1a35;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   $1026                   ; 0AE2: BD 10 26      \n");
    memory[--S] = 0x0ae5 & 0xff; memory[--S] = 0x0ae5 >> 8;
    PC = 0x1026;
    JUMP;
  case 0x0AE5:                                       mon("L0AE5    LDA   $C8D2                   ; 0AE5: B6 C8 D2      \n");
    A = (UINT8)memory[0xc8d2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0AF7                   ; 0AE8: 26 0D         \n");
    if (Z) {
    PC = 0x0af7;
    JUMP;
    }
                                                     mon("         LDA   $C8EC                   ; 0AEA: B6 C8 EC      \n");
    A = (UINT8)memory[0xc8ec];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0AF4                   ; 0AED: 27 05         \n");
    if (!Z) {
    PC = 0x0af4;
    JUMP;
    }
                                                     mon("         LDA   $C8D0                   ; 0AEF: B6 C8 D0      \n");
    A = (UINT8)memory[0xc8d0];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BEQ   $0AF7                   ; 0AF2: 27 03         \n");
    if (!Z) {
    PC = 0x0af7;
    JUMP;
    }
  case 0x0AF4:                                       mon("L0AF4    JSR   $0D8B                   ; 0AF4: BD 0D 8B      \n");
    memory[--S] = 0x0af7 & 0xff; memory[--S] = 0x0af7 >> 8;
    PC = 0x0d8b;
    JUMP;
  case 0x0AF7:                                       mon("L0AF7    JSR   Do_Sound                ; 0AF7: BD F2 89      \n");
    memory[--S] = 0x0afa & 0xff; memory[--S] = 0x0afa >> 8;
    PC = 0xf289;
    JUMP;
  case 0x0AFA:                                       mon("L0AFA    JMP   $0127                   ; 0AFA: 7E 01 27      \n");
    PC = 0x0127;
    JUMP;
    
  case 0x0AFD:                                       mon("L0AFD    LDX   #$CA63                  ; 0AFD: 8E CA 63      \n");
    X = 0xca63;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$8F3F                  ; 0B00: CC 8F 3F      \n");
    A = (UINT8)((0x8f3f) >> 8);
    B = (UINT8)((0x8f3f) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   ,X++                    ; 0B03: ED 81         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[X] = A;
    memory[X + 1] = B;
    X = X + 2;
                                                     mon("         JSR   Clear_Score             ; 0B05: BD F8 4F      \n");
    memory[--S] = 0x0b08 & 0xff; memory[--S] = 0x0b08 >> 8;
    PC = 0xf84f;
    JUMP;
  case 0x0B08:                                       mon("L0B08    LEAU  $06,X                   ; 0B08: 33 06         \n");
    U = (X + 0x0006);
                                                     mon("         LDX   #$1ABC                  ; 0B0A: 8E 1A BC      \n");
    X = 0x1abc;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   <$E1                    ; 0B0D: D6 E1         \n");
    B = (UINT8)memory_DP[0xe1];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDB   [B,X]                   ; 0B0F: E6 95         \n");
    B = (UINT8)memory[((memory[(UINT16)(X + (SINT8)B)]<<8)|memory[(UINT16)(X + (SINT8)B + 1)])];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   #$20                    ; 0B11: 86 20         \n");
    A = (UINT8)(SINT8)0x20;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   ,-U                     ; 0B13: A7 C2         \n");
    U = U - 1;
 // Z = A;
 // N = A;
 // V = 0;
    memory[U] = A;
                                                     mon("         INCA                          ; 0B15: 4C            \n");
    res = (UINT8)(A + 1);
 // Z = res;
 // N = res;
 // V = res & ~(A);
    A = res;
  case 0x0B16:                                       mon("L0B16    DECB                          ; 0B16: 5A            \n");
    res = (UINT8)(B - 1);
 // N = res;
    Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         BEQ   $0B1D                   ; 0B17: 27 04         \n");
    if (!Z) {
    PC = 0x0b1d;
    JUMP;
    }
                                                     mon("         STA   ,-U                     ; 0B19: A7 C2         \n");
    U = U - 1;
    Z = A;
    N = A;
    V = 0;
    memory[U] = A;
                                                     mon("         BRA   $0B16                   ; 0B1B: 20 F9         \n");
    PC = 0x0b16;
    JUMP;
    
  case 0x0B1D:                                       mon("L0B1D    RTS                           ; 0B1D: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0B1E:                                       mon("L0B1E    TFR   A,B                     ; 0B1E: 1F 89         \n");
    B = A;
                                                     mon("         ANDA  #$F0                    ; 0B20: 84 F0         \n");
    A = A & (SINT8)0xf0;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ANDB  #$0F                    ; 0B22: C4 0F         \n");
    B = B & (SINT8)0x0f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         DECB                          ; 0B24: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         BPL   $0B2F                   ; 0B25: 2A 08         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0b2f;
    JUMP;
    }
                                                     mon("         LDB   #$09                    ; 0B27: C6 09         \n");
    B = (UINT8)(SINT8)0x09;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBA  #$10                    ; 0B29: 80 10         \n");
    res = A - (SINT8)0x10;
    C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x10) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BPL   $0B2F                   ; 0B2B: 2A 02         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0b2f;
    JUMP;
    }
                                                     mon("         LDA   #$90                    ; 0B2D: 86 90         \n");
    A = (UINT8)(SINT8)0x90;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x0B2F:                                       mon("L0B2F    PSHS  B                       ; 0B2F: 34 04         \n");
    memory[--S] = B;
                                                     mon("         ORA   ,S+                     ; 0B31: AA E0         \n");
    A = A | memory[S];
    Z = A;
    N = A;
    V = 0;
    S = S + 1;
                                                     mon("         RTS                           ; 0B33: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0B34:                                       mon("L0B34    PSHS  A                       ; 0B34: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   <$11                    ; 0B36: 96 11         \n");
    A = (UINT8)memory_DP[0x11];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$01                    ; 0B38: 84 01         \n");
    A = A & (SINT8)0x01;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         EORA  <$D2                    ; 0B3A: 98 D2         \n");
    A = A ^ memory_DP[0xd2];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$D2                    ; 0B3C: 97 D2         \n");
 // Z = A;
 // N = A;
    V = 0;
    memory_DP[0xd2] = A;
                                                     mon("         RORA                          ; 0B3E: 46            \n");
    res = ((UINT8)A) | ((C != 0) ? 0x100 : 0);
    C = res & 1;
    res = (UINT8)(res >> 1);
    Z = res;
    N = res;
    A = res;
                                                     mon("         BCC   $0B48                   ; 0B3F: 24 07         \n");
    if (!C) {
    PC = 0x0b48;
    JUMP;
    }
                                                     mon("         PSHS  CC                      ; 0B41: 34 01         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    memory[--S] = CC;
                                                     mon("         JSR   Init_Music_Buf          ; 0B43: BD F5 33      \n");
    memory[--S] = 0x0b46 & 0xff; memory[--S] = 0x0b46 >> 8;
    PC = 0xf533;
    JUMP;
  case 0x0B46:                                       mon("L0B46    PULS  CC                      ; 0B46: 35 01         \n");
    CC = memory[S++];
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
  case 0x0B48:                                       mon("L0B48    LDA   <$11                    ; 0B48: 96 11         \n");
    A = (UINT8)memory_DP[0x11];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$FE                    ; 0B4A: 84 FE         \n");
    A = A & (SINT8)0xfe;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$11                    ; 0B4C: 97 11         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x11] = A;
                                                     mon("         PULS  A,PC                    ; 0B4E: 35 82         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0B50:                                       mon("L0B50    LDD   #$0100                  ; 0B50: CC 01 00      \n");
    A = (UINT8)((0x0100) >> 8);
    B = (UINT8)((0x0100) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$C5                    ; 0B53: DD C5         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xc5] = A;
    memory_DP[0xc5 + 1] = B;
  case 0x0B55:                                       mon("L0B55    LDA   #$20                    ; 0B55: 86 20         \n");
    A = (UINT8)(SINT8)0x20;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$86                    ; 0B57: 97 86         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x86] = A;
                                                     mon("         CLRA                          ; 0B59: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   #$06                    ; 0B5A: C6 06         \n");
    B = (UINT8)(SINT8)0x06;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDX   #$CA6D                  ; 0B5C: 8E CA 6D      \n");
    X = 0xca6d;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
  case 0x0B5F:                                       mon("L0B5F    STA   B,X                     ; 0B5F: A7 85         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(X + (SINT8)B)] = A;
                                                     mon("         ADDA  #$10                    ; 0B61: 8B 10         \n");
    res = A + (SINT8)0x10;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         DECB                          ; 0B63: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
    Z = res;
    V = B & ~res;
    B = res;
                                                     mon("         BPL   $0B5F                   ; 0B64: 2A F9         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0b5f;
    JUMP;
    }
                                                     mon("         RTS                           ; 0B66: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0B67:                                       mon("L0B67    PSHS  B,A                     ; 0B67: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDB   $C8D0                   ; 0B69: F6 C8 D0      \n");
    B = (UINT8)memory[0xc8d0];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         CMPB  #$0E                    ; 0B6C: C1 0E         \n");
    res = B - (SINT8)0x0e;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x0e) & (B ^ (UINT8)res);
                                                     mon("         BCC   $0B7A                   ; 0B6E: 24 0A         \n");
    if (!C) {
    PC = 0x0b7a;
    JUMP;
    }
                                                     mon("         LDB   $C8DA                   ; 0B70: F6 C8 DA      \n");
    B = (UINT8)memory[0xc8da];
    N = B;
    Z = B;
    V = 0;
                                                     mon("         BNE   $0B7A                   ; 0B73: 26 05         \n");
    if (Z) {
    PC = 0x0b7a;
    JUMP;
    }
                                                     mon("         PULS  A,B                     ; 0B75: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         JMP   Moveto_d_7F             ; 0B77: 7E F2 FC      \n");
    PC = 0xf2fc;
    JUMP;
    
  case 0x0B7A:                                       mon("L0B7A    JSR   Random                  ; 0B7A: BD F5 17      \n");
    memory[--S] = 0x0b7d & 0xff; memory[--S] = 0x0b7d >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0B7D:                                       mon("L0B7D    JSR   $10F6                   ; 0B7D: BD 10 F6      \n");
    memory[--S] = 0x0b80 & 0xff; memory[--S] = 0x0b80 >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x0B80:                                       mon("L0B80    ASRA                          ; 0B80: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0B81: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0B82: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0B83: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0B84: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ADDA  ,S+                     ; 0B85: AB E0         \n");
    res = A + memory[S];
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory[S] ^ (UINT8)res ^ C;
 // V = A ^ memory[S] ^ (UINT8)res ^ C;
    A = (UINT8)res;
    S = S + 1;
                                                     mon("         LSRB                          ; 0B87: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0B88: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0B89: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0B8A: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0B8B: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0B8C: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         ADDB  ,S+                     ; 0B8D: EB E0         \n");
    res = B + memory[S];
    C = (res >> 1) & 0x80;
    Z = (UINT8)res;
    N = (UINT8)res;
    H = B ^ memory[S] ^ (UINT8)res ^ C;
    V = B ^ memory[S] ^ (UINT8)res ^ C;
    B = (UINT8)res;
    S = S + 1;
                                                     mon("         JMP   Moveto_d_7F             ; 0B8F: 7E F2 FC      \n");
    PC = 0xf2fc;
    JUMP;
    
  case 0x0B92:                                       mon("L0B92    LDA   $C8BA                   ; 0B92: B6 C8 BA      \n");
    A = (UINT8)memory[0xc8ba];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 0B95: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         STA   $C8B4                   ; 0B96: B7 C8 B4      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b4] = A;
                                                     mon("         LDA   #$FF                    ; 0B99: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8B4                   ; 0B9B: B0 C8 B4      \n");
    res = A - memory[0xc8b4];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[0xc8b4]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         STA   $C8B4                   ; 0B9E: B7 C8 B4      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b4] = A;
  case 0x0BA1:                                       mon("L0BA1    CLR   $C8B5                   ; 0BA1: 7F C8 B5      \n");
    memory[0xc8b5] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   $C8BB                   ; 0BA4: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 0BA7: BD F2 FC      \n");
    memory[--S] = 0x0baa & 0xff; memory[--S] = 0x0baa >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x0BAA:                                       mon("L0BAA    PSHS  DP                      ; 0BAA: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDA   #$C8                    ; 0BAC: 86 C8         \n");
    A = (UINT8)(SINT8)0xc8;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 0BAE: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDB   <$BC                    ; 0BB0: D6 BC         \n");
    B = (UINT8)memory_DP[0xbc];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0BB2: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         STD   <$AA                    ; 0BB3: DD AA         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xaa] = A;
    memory_DP[0xaa + 1] = B;
                                                     mon("         STD   <$AE                    ; 0BB5: DD AE         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xae] = A;
    memory_DP[0xae + 1] = B;
                                                     mon("         LDB   <$BB                    ; 0BB7: D6 BB         \n");
    B = (UINT8)memory_DP[0xbb];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0BB9: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         STD   <$A8                    ; 0BBA: DD A8         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xa8] = A;
    memory_DP[0xa8 + 1] = B;
                                                     mon("         STD   <$AC                    ; 0BBC: DD AC         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xac] = A;
    memory_DP[0xac + 1] = B;
                                                     mon("         CLR   <$A3                    ; 0BBE: 0F A3         \n");
    memory_DP[0xa3] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CMPD  #$78                    ; 0BC0: 10 83 00 78   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0078);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0078)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGE   $0BCC                   ; 0BC4: 2C 06         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x0bcc;
    JUMP;
    }
                                                     mon("         CMPD  #$FFC8                  ; 0BC6: 10 83 FF C8   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xffc8);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xffc8)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $0BD0                   ; 0BCA: 2E 04         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x0bd0;
    JUMP;
    }
  case 0x0BCC:                                       mon("L0BCC    LDA   #$02                    ; 0BCC: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$A3                    ; 0BCE: 97 A3         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xa3] = A;
  case 0x0BD0:                                       mon("L0BD0    LDA   ,X+                     ; 0BD0: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         STA   <$23                    ; 0BD2: 97 23         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x23] = A;
  case 0x0BD4:                                       mon("L0BD4    DEC   <$23                    ; 0BD4: 0A 23         \n");
    res = (UINT8)(memory_DP[0x23] - 1);
    N = res;
 // Z = res;
 // V = memory_DP[0x23] & ~res;
    memory_DP[0x23] = res;
                                                     mon("         BPL   $0BEC                   ; 0BD6: 2A 14         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0bec;
    JUMP;
    }
                                                     mon("         LDA   #$D0                    ; 0BD8: 86 D0         \n");
    A = (UINT8)(SINT8)0xd0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 0BDA: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDB   #$40                    ; 0BDC: C6 40         \n");
    B = (UINT8)(SINT8)0x40;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x0BDE:                                       mon("L0BDE    BITB  <$0D                    ; 0BDE: D5 0D         \n");
    res = B & memory_DP[0x0d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0BDE                   ; 0BE0: 27 FC         \n");
    if (!Z) {
    PC = 0x0bde;
    JUMP;
    }
                                                     mon("         CLR   <$0A                    ; 0BE2: 0F 0A         \n");
    memory_DP[0x0a] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   Vec_Misc_Count          ; 0BE4: 7F C8 23      \n");
    memory[0xc823] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         JSR   Check0Ref               ; 0BE7: BD F3 4F      \n");
    memory[--S] = 0x0bea & 0xff; memory[--S] = 0x0bea >> 8;
    PC = 0xf34f;
    JUMP;
  case 0x0BEA:                                       mon("L0BEA    PULS  DP,PC                   ; 0BEA: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0BEC:                                       mon("L0BEC    ASL   <$B6                    ; 0BEC: 08 B6         \n");
    res = memory_DP[0xb6] << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = memory_DP[0xb6] ^ res;
    memory_DP[0xb6] = res;
                                                     mon("         DEC   <$B5                    ; 0BEE: 0A B5         \n");
    res = (UINT8)(memory_DP[0xb5] - 1);
    N = res;
 // Z = res;
 // V = memory_DP[0xb5] & ~res;
    memory_DP[0xb5] = res;
                                                     mon("         BPL   $0BFA                   ; 0BF0: 2A 08         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0bfa;
    JUMP;
    }
                                                     mon("         LDA   #$07                    ; 0BF2: 86 07         \n");
    A = (UINT8)(SINT8)0x07;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$B5                    ; 0BF4: 97 B5         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xb5] = A;
                                                     mon("         LDA   ,X+                     ; 0BF6: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         STA   <$B6                    ; 0BF8: 97 B6         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xb6] = A;
  case 0x0BFA:                                       mon("L0BFA    LDD   <$A8                    ; 0BFA: DC A8         \n");
    A = memory_DP[0xa8];
    B = memory_DP[0xa8 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$A4                    ; 0BFC: DD A4         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xa4] = A;
    memory_DP[0xa4 + 1] = B;
                                                     mon("         LDD   <$AA                    ; 0BFE: DC AA         \n");
    A = memory_DP[0xaa];
    B = memory_DP[0xaa + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$A6                    ; 0C00: DD A6         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xa6] = A;
    memory_DP[0xa6 + 1] = B;
                                                     mon("         LDA   #$40                    ; 0C02: 86 40         \n");
    A = (UINT8)(SINT8)0x40;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  VIA_int_flags           ; 0C04: B5 D0 0D      \n");
    res = A & memory[0xd00d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0C0C                   ; 0C07: 27 03         \n");
    if (!Z) {
    PC = 0x0c0c;
    JUMP;
    }
                                                     mon("         CLR   VIA_shift_reg           ; 0C09: 7F D0 0A      \n");
    memory[0xd00a] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0C0C:                                       mon("L0C0C    CLR   <$9B                    ; 0C0C: 0F 9B         \n");
    memory_DP[0x9b] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         LDA   #$7F                    ; 0C0E: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   VIA_t1_lch_lo           ; 0C10: B7 D0 06      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xd006] = A;
                                                     mon("         LDB   $01,X                   ; 0C13: E6 01         \n");
    B = (UINT8)memory[(UINT16)(X + 0x0001)];
    N = B;
    Z = B;
    V = 0;
                                                     mon("         PSHS  CC                      ; 0C15: 34 01         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    memory[--S] = CC;
                                                     mon("         BPL   $0C1A                   ; 0C17: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0c1a;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0C19: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0C1A:                                       mon("L0C1A    CMPB  #$3F                    ; 0C1A: C1 3F         \n");
    res = B - (SINT8)0x3f;
 // C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (B ^ (SINT8)0x3f) & (B ^ (UINT8)res);
                                                     mon("         BLE   $0C20                   ; 0C1C: 2F 02         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x0c20;
    JUMP;
    }
                                                     mon("         INC   <$9B                    ; 0C1E: 0C 9B         \n");
    res = (UINT8)(memory_DP[0x9b] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9b]);
    memory_DP[0x9b] = res;
  case 0x0C20:                                       mon("L0C20    LDA   #$40                    ; 0C20: 86 40         \n");
    A = (UINT8)(SINT8)0x40;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  VIA_int_flags           ; 0C22: B5 D0 0D      \n");
    res = A & memory[0xd00d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0C2A                   ; 0C25: 27 03         \n");
    if (!Z) {
    PC = 0x0c2a;
    JUMP;
    }
                                                     mon("         CLR   VIA_shift_reg           ; 0C27: 7F D0 0A      \n");
    memory[0xd00a] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0C2A:                                       mon("L0C2A    LDA   <$B4                    ; 0C2A: 96 B4         \n");
    A = (UINT8)memory_DP[0xb4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         MUL                           ; 0C2C: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 0C2D: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         TFR   A,B                     ; 0C2F: 1F 89         \n");
    B = A;
                                                     mon("         PULS  CC                      ; 0C31: 35 01         \n");
    CC = memory[S++];
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         BPL   $0C36                   ; 0C33: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0c36;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0C35: 50            \n");
 // V = (UINT8)(-B) & (B);
    C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0C36:                                       mon("L0C36    STB   <$98                    ; 0C36: D7 98         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x98] = B;
                                                     mon("         LDB   ,X++                    ; 0C38: E6 81         \n");
    B = (UINT8)memory[X];
    N = B;
    Z = B;
    V = 0;
    X = X + 2;
                                                     mon("         PSHS  CC                      ; 0C3A: 34 01         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    memory[--S] = CC;
                                                     mon("         BPL   $0C3F                   ; 0C3C: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0c3f;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0C3E: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0C3F:                                       mon("L0C3F    CMPB  #$3F                    ; 0C3F: C1 3F         \n");
    res = B - (SINT8)0x3f;
 // C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (B ^ (SINT8)0x3f) & (B ^ (UINT8)res);
                                                     mon("         BLE   $0C45                   ; 0C41: 2F 02         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x0c45;
    JUMP;
    }
                                                     mon("         INC   <$9B                    ; 0C43: 0C 9B         \n");
    res = (UINT8)(memory_DP[0x9b] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9b]);
    memory_DP[0x9b] = res;
  case 0x0C45:                                       mon("L0C45    LDA   <$B4                    ; 0C45: 96 B4         \n");
    A = (UINT8)memory_DP[0xb4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         MUL                           ; 0C47: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 0C48: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         TFR   A,B                     ; 0C4A: 1F 89         \n");
    B = A;
                                                     mon("         PULS  CC                      ; 0C4C: 35 01         \n");
    CC = memory[S++];
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         BPL   $0C51                   ; 0C4E: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0c51;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0C50: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0C51:                                       mon("L0C51    STB   <$97                    ; 0C51: D7 97         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x97] = B;
                                                     mon("         LDA   <$9B                    ; 0C53: 96 9B         \n");
    A = (UINT8)memory_DP[0x9b];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0C5E                   ; 0C55: 26 07         \n");
    if (Z) {
    PC = 0x0c5e;
    JUMP;
    }
                                                     mon("         ASR   VIA_t1_lch_lo           ; 0C57: 77 D0 06      \n");
 // C = memory[0xd006] & 1;
    memory[0xd006] = (UINT8)((SINT8)memory[0xd006] >> 1);
 // Z = memory[0xd006];
 // N = memory[0xd006];
                                                     mon("         ASL   <$97                    ; 0C5A: 08 97         \n");
    res = memory_DP[0x97] << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = memory_DP[0x97] ^ res;
    memory_DP[0x97] = res;
                                                     mon("         ASL   <$98                    ; 0C5C: 08 98         \n");
    res = memory_DP[0x98] << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = memory_DP[0x98] ^ res;
    memory_DP[0x98] = res;
  case 0x0C5E:                                       mon("L0C5E    LDB   <$98                    ; 0C5E: D6 98         \n");
    B = (UINT8)memory_DP[0x98];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0C60: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A6                    ; 0C61: D3 A6         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$AA                    ; 0C63: DD AA         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xaa] = A;
    memory_DP[0xaa + 1] = B;
                                                     mon("         STD   <$B2                    ; 0C65: DD B2         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xb2] = A;
    memory_DP[0xb2 + 1] = B;
                                                     mon("         LDB   <$97                    ; 0C67: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0C69: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A4                    ; 0C6A: D3 A4         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$A8                    ; 0C6C: DD A8         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xa8] = A;
    memory_DP[0xa8 + 1] = B;
                                                     mon("         STD   <$B0                    ; 0C6E: DD B0         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xb0] = A;
    memory_DP[0xb0 + 1] = B;
  case 0x0C70:                                       mon("L0C70    CMPD  #$78                    ; 0C70: 10 83 00 78   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0078);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0078)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $0CCF                   ; 0C74: 2E 59         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x0ccf;
    JUMP;
    }
                                                     mon("         CMPD  #$FFC8                  ; 0C76: 10 83 FF C8   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xffc8);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xffc8)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $0CCF                   ; 0C7A: 2D 53         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x0ccf;
    JUMP;
    }
                                                     mon("         BNE   $0C88                   ; 0C7C: 26 0A         \n");
    if (Z) {
    PC = 0x0c88;
    JUMP;
    }
                                                     mon("         LDA   <$A3                    ; 0C7E: 96 A3         \n");
    A = (UINT8)memory_DP[0xa3];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0C8C                   ; 0C80: 26 0A         \n");
    if (Z) {
    PC = 0x0c8c;
    JUMP;
    }
                                                     mon("         LDA   #$02                    ; 0C82: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$A3                    ; 0C84: 97 A3         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0xa3] = A;
                                                     mon("         BRA   $0C9B                   ; 0C86: 20 13         \n");
    PC = 0x0c9b;
    JUMP;
    
  case 0x0C88:                                       mon("L0C88    LDA   <$A3                    ; 0C88: 96 A3         \n");
    A = (UINT8)memory_DP[0xa3];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0C9B                   ; 0C8A: 27 0F         \n");
    if (!Z) {
    PC = 0x0c9b;
    JUMP;
    }
  case 0x0C8C:                                       mon("L0C8C    CMPA  #$01                    ; 0C8C: 81 01         \n");
    res = A - (SINT8)0x01;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x01) & (A ^ (UINT8)res);
                                                     mon("         BEQ   $0C97                   ; 0C8E: 27 07         \n");
    if (!Z) {
    PC = 0x0c97;
    JUMP;
    }
                                                     mon("         LDA   #$03                    ; 0C90: 86 03         \n");
    A = (UINT8)(SINT8)0x03;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$A3                    ; 0C92: 97 A3         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0xa3] = A;
                                                     mon("         JMP   $0CDA                   ; 0C94: 7E 0C DA      \n");
    PC = 0x0cda;
    JUMP;
    
  case 0x0C97:                                       mon("L0C97    LDA   #$02                    ; 0C97: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$A3                    ; 0C99: 97 A3         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xa3] = A;
  case 0x0C9B:                                       mon("L0C9B    LDD   <$B0                    ; 0C9B: DC B0         \n");
    A = memory_DP[0xb0];
    B = memory_DP[0xb0 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$AC                    ; 0C9D: DD AC         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xac] = A;
    memory_DP[0xac + 1] = B;
                                                     mon("         LDD   <$B2                    ; 0C9F: DC B2         \n");
    A = memory_DP[0xb2];
    B = memory_DP[0xb2 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$AE                    ; 0CA1: DD AE         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xae] = A;
    memory_DP[0xae + 1] = B;
                                                     mon("         PSHS  DP                      ; 0CA3: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDA   #$D0                    ; 0CA5: 86 D0         \n");
    A = (UINT8)(SINT8)0xd0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 0CA7: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDB   #$40                    ; 0CA9: C6 40         \n");
    B = (UINT8)(SINT8)0x40;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x0CAB:                                       mon("L0CAB    BITB  <$0D                    ; 0CAB: D5 0D         \n");
    res = B & memory_DP[0x0d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0CAB                   ; 0CAD: 27 FC         \n");
    if (!Z) {
    PC = 0x0cab;
    JUMP;
    }
                                                     mon("         LDD   $C897                   ; 0CAF: FC C8 97      \n");
    A = memory[0xc897];
    B = memory[(UINT16)((0xc897)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$01                    ; 0CB2: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         CLR   <$00                    ; 0CB4: 0F 00         \n");
    memory_DP[0x00] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         TFR   B,A                     ; 0CB6: 1F 98         \n");
    A = B;
                                                     mon("         LDB   $C8B6                   ; 0CB8: F6 C8 B6      \n");
    B = (UINT8)memory[0xc8b6];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         INC   <$00                    ; 0CBB: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         TST   $C8A2                   ; 0CBD: 7D C8 A2      \n");
    Z = memory[0xc8a2];
 // N = memory[0xc8a2];
 // V = 0;
                                                     mon("         BEQ   $0CC3                   ; 0CC0: 27 01         \n");
    if (!Z) {
    PC = 0x0cc3;
    JUMP;
    }
                                                     mon("         NEGA                          ; 0CC2: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x0CC3:                                       mon("L0CC3    STA   <$01                    ; 0CC3: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         SEX                           ; 0CC5: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         STA   <$0A                    ; 0CC6: 97 0A         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0a] = A;
                                                     mon("         CLR   <$05                    ; 0CC8: 0F 05         \n");
    memory_DP[0x05] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         PULS  DP                      ; 0CCA: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         JMP   $0BD4                   ; 0CCC: 7E 0B D4      \n");
    PC = 0x0bd4;
    JUMP;
    
  case 0x0CCF:                                       mon("L0CCF    LDA   <$A3                    ; 0CCF: 96 A3         \n");
    A = (UINT8)memory_DP[0xa3];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0CDA                   ; 0CD1: 27 07         \n");
    if (!Z) {
    PC = 0x0cda;
    JUMP;
    }
                                                     mon("         CMPA  #$02                    ; 0CD3: 81 02         \n");
    res = A - (SINT8)0x02;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0x02) & (A ^ (UINT8)res);
                                                     mon("         BNE   $0D04                   ; 0CD5: 26 2D         \n");
    if (Z) {
    PC = 0x0d04;
    JUMP;
    }
  case 0x0CD7:                                       mon("L0CD7    JMP   $0BD4                   ; 0CD7: 7E 0B D4      \n");
    PC = 0x0bd4;
    JUMP;
    
  case 0x0CDA:                                       mon("L0CDA    ASR   <$97                    ; 0CDA: 07 97         \n");
 // C = memory_DP[0x97] & 1;
    memory_DP[0x97] = (UINT8)((SINT8)memory_DP[0x97] >> 1);
 // Z = memory_DP[0x97];
 // N = memory_DP[0x97];
                                                     mon("         ASR   <$98                    ; 0CDC: 07 98         \n");
 // C = memory_DP[0x98] & 1;
    memory_DP[0x98] = (UINT8)((SINT8)memory_DP[0x98] >> 1);
 // Z = memory_DP[0x98];
 // N = memory_DP[0x98];
                                                     mon("         CMPA  #$03                    ; 0CDE: 81 03         \n");
    res = A - (SINT8)0x03;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x03) & (A ^ (UINT8)res);
                                                     mon("         BEQ   $0CE6                   ; 0CE0: 27 04         \n");
    if (!Z) {
    PC = 0x0ce6;
    JUMP;
    }
                                                     mon("         LDA   #$01                    ; 0CE2: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$A3                    ; 0CE4: 97 A3         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xa3] = A;
  case 0x0CE6:                                       mon("L0CE6    LDB   <$98                    ; 0CE6: D6 98         \n");
    B = (UINT8)memory_DP[0x98];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0CE8: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A6                    ; 0CE9: D3 A6         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$B2                    ; 0CEB: DD B2         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xb2] = A;
    memory_DP[0xb2 + 1] = B;
                                                     mon("         LDB   <$97                    ; 0CED: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 0CEF: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A4                    ; 0CF0: D3 A4         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  <$B0                    ; 0CF2: 10 93 B0      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xb0]<<8)|memory_DP[0xb0 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xb0]<<8)|memory_DP[0xb0 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BNE   $0CFF                   ; 0CF5: 26 08         \n");
    if (Z) {
    PC = 0x0cff;
    JUMP;
    }
                                                     mon("         LDA   <$A3                    ; 0CF7: 96 A3         \n");
    A = (UINT8)memory_DP[0xa3];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$03                    ; 0CF9: 81 03         \n");
    res = A - (SINT8)0x03;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0x03) & (A ^ (UINT8)res);
                                                     mon("         BEQ   $0D04                   ; 0CFB: 27 07         \n");
    if (!Z) {
    PC = 0x0d04;
    JUMP;
    }
                                                     mon("         BRA   $0CD7                   ; 0CFD: 20 D8         \n");
    PC = 0x0cd7;
    JUMP;
    
  case 0x0CFF:                                       mon("L0CFF    STD   <$B0                    ; 0CFF: DD B0         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0xb0] = A;
    memory_DP[0xb0 + 1] = B;
                                                     mon("         JMP   $0C70                   ; 0D01: 7E 0C 70      \n");
    PC = 0x0c70;
    JUMP;
    
  case 0x0D04:                                       mon("L0D04    CMPA  #$03                    ; 0D04: 81 03         \n");
    res = A - (SINT8)0x03;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x03) & (A ^ (UINT8)res);
                                                     mon("         BNE   $0CDA                   ; 0D06: 26 D2         \n");
    if (Z) {
    PC = 0x0cda;
    JUMP;
    }
                                                     mon("         CLR   <$9E                    ; 0D08: 0F 9E         \n");
    memory_DP[0x9e] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   <$97                    ; 0D0A: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ASLB                          ; 0D0C: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         SEX                           ; 0D0D: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A4                    ; 0D0E: D3 A4         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa4]<<8)|memory_DP[0xa4 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         PSHS  B                       ; 0D10: 34 04         \n");
    memory[--S] = B;
                                                     mon("         SUBD  <$AC                    ; 0D12: 93 AC         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0xac]<<8)|memory_DP[0xac + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0xac]<<8)|memory_DP[0xac + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$7F                    ; 0D14: 10 83 00 7F   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x007f);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x007f)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $0D20                   ; 0D18: 2E 06         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x0d20;
    JUMP;
    }
                                                     mon("         CMPD  #$FF81                  ; 0D1A: 10 83 FF 81   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xff81);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xff81)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGE   $0D24                   ; 0D1E: 2C 04         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x0d24;
    JUMP;
    }
  case 0x0D20:                                       mon("L0D20    INC   <$9E                    ; 0D20: 0C 9E         \n");
    res = (UINT8)(memory_DP[0x9e] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9e]);
    memory_DP[0x9e] = res;
                                                     mon("         ASRA                          ; 0D22: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0D23: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
  case 0x0D24:                                       mon("L0D24    STB   <$99                    ; 0D24: D7 99         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x99] = B;
                                                     mon("         LDB   <$98                    ; 0D26: D6 98         \n");
    B = (UINT8)memory_DP[0x98];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ASLB                          ; 0D28: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         SEX                           ; 0D29: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$A6                    ; 0D2A: D3 A6         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xa6]<<8)|memory_DP[0xa6 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         PSHS  B                       ; 0D2C: 34 04         \n");
    memory[--S] = B;
                                                     mon("         SUBD  <$AE                    ; 0D2E: 93 AE         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0xae]<<8)|memory_DP[0xae + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0xae]<<8)|memory_DP[0xae + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         TST   <$9E                    ; 0D30: 0D 9E         \n");
    Z = memory_DP[0x9e];
 // N = memory_DP[0x9e];
 // V = 0;
                                                     mon("         BNE   $0D42                   ; 0D32: 26 0E         \n");
    if (Z) {
    PC = 0x0d42;
    JUMP;
    }
                                                     mon("         CMPD  #$7F                    ; 0D34: 10 83 00 7F   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x007f);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x007f)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $0D40                   ; 0D38: 2E 06         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x0d40;
    JUMP;
    }
                                                     mon("         CMPD  #$FF81                  ; 0D3A: 10 83 FF 81   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xff81);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xff81)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGE   $0D44                   ; 0D3E: 2C 04         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x0d44;
    JUMP;
    }
  case 0x0D40:                                       mon("L0D40    INC   <$9E                    ; 0D40: 0C 9E         \n");
    res = (UINT8)(memory_DP[0x9e] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9e]);
    memory_DP[0x9e] = res;
  case 0x0D42:                                       mon("L0D42    ASRA                          ; 0D42: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0D43: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
  case 0x0D44:                                       mon("L0D44    STB   <$9A                    ; 0D44: D7 9A         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x9a] = B;
                                                     mon("         PSHS  DP                      ; 0D46: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDA   #$D0                    ; 0D48: 86 D0         \n");
    A = (UINT8)(SINT8)0xd0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 0D4A: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
  case 0x0D4C:                                       mon("L0D4C    LDB   #$40                    ; 0D4C: C6 40         \n");
    B = (UINT8)(SINT8)0x40;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x0D4E:                                       mon("L0D4E    BITB  <$0D                    ; 0D4E: D5 0D         \n");
    res = B & memory_DP[0x0d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $0D4E                   ; 0D50: 27 FC         \n");
    if (!Z) {
    PC = 0x0d4e;
    JUMP;
    }
                                                     mon("         CLR   <$0A                    ; 0D52: 0F 0A         \n");
    memory_DP[0x0a] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDD   $C899                   ; 0D54: FC C8 99      \n");
    A = memory[0xc899];
    B = memory[(UINT16)((0xc899)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$01                    ; 0D57: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         CLR   <$00                    ; 0D59: 0F 00         \n");
    memory_DP[0x00] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         NOP                           ; 0D5B: 12            \n");
                                                     mon("         NOP                           ; 0D5C: 12            \n");
                                                     mon("         INC   <$00                    ; 0D5D: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         TST   $C8A2                   ; 0D5F: 7D C8 A2      \n");
    Z = memory[0xc8a2];
 // N = memory[0xc8a2];
 // V = 0;
                                                     mon("         BEQ   $0D65                   ; 0D62: 27 01         \n");
    if (!Z) {
    PC = 0x0d65;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0D64: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0D65:                                       mon("L0D65    STB   <$01                    ; 0D65: D7 01         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x01] = B;
                                                     mon("         CLR   <$05                    ; 0D67: 0F 05         \n");
    memory_DP[0x05] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         DEC   $C89E                   ; 0D69: 7A C8 9E      \n");
    res = (UINT8)(memory[0xc89e] - 1);
    N = res;
 // Z = res;
 // V = memory[0xc89e] & ~res;
    memory[0xc89e] = res;
                                                     mon("         BPL   $0D4C                   ; 0D6C: 2A DE         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0d4c;
    JUMP;
    }
                                                     mon("         PULS  DP                      ; 0D6E: 35 08         \n");
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDB   ,S+                     ; 0D70: E6 E0         \n");
    B = (UINT8)memory[S];
 // N = B;
 // Z = B;
 // V = 0;
    S = S + 1;
                                                     mon("         SEX                           ; 0D72: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         PSHS  B,A                     ; 0D73: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   <$AA                    ; 0D75: DC AA         \n");
    A = memory_DP[0xaa];
    B = memory_DP[0xaa + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  ,S++                    ; 0D77: A3 E1         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STB   <$98                    ; 0D79: D7 98         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x98] = B;
                                                     mon("         LDB   ,S+                     ; 0D7B: E6 E0         \n");
    B = (UINT8)memory[S];
 // N = B;
 // Z = B;
 // V = 0;
    S = S + 1;
                                                     mon("         SEX                           ; 0D7D: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         PSHS  B,A                     ; 0D7E: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   <$A8                    ; 0D80: DC A8         \n");
    A = memory_DP[0xa8];
    B = memory_DP[0xa8 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  ,S++                    ; 0D82: A3 E1         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STB   <$97                    ; 0D84: D7 97         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x97] = B;
                                                     mon("         CLR   <$A3                    ; 0D86: 0F A3         \n");
    memory_DP[0xa3] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         JMP   $0C9B                   ; 0D88: 7E 0C 9B      \n");
    PC = 0x0c9b;
    JUMP;
    
  case 0x0D8B:                                       mon("L0D8B    PSHS  DP                      ; 0D8B: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDA   #$C8                    ; 0D8D: 86 C8         \n");
    A = (UINT8)(SINT8)0xc8;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,DP                    ; 0D8F: 1F 8B         \n");
    DP = (A) << 8;
    memory_DP = &memory[DP];
                                                     mon("         LDA   <$56                    ; 0D91: 96 56         \n");
    A = (UINT8)memory_DP[0x56];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0DAB                   ; 0D93: 26 16         \n");
    if (Z) {
    PC = 0x0dab;
    JUMP;
    }
                                                     mon("         LDB   <$D3                    ; 0D95: D6 D3         \n");
    B = (UINT8)memory_DP[0xd3];
    N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0DAD                   ; 0D97: 27 14         \n");
    if (!Z) {
    PC = 0x0dad;
    JUMP;
    }
                                                     mon("         BPL   $0DAB                   ; 0D99: 2A 10         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0dab;
    JUMP;
    }
                                                     mon("         NEG   <$D3                    ; 0D9B: 00 D3         \n");
 // V = (UINT8)(-memory_DP[0xd3]) & (memory_DP[0xd3]);
 // C = (-memory_DP[0xd3]) & 0x100;
    memory_DP[0xd3] = (UINT8)(-memory_DP[0xd3]);
 // Z = memory_DP[0xd3];
 // N = memory_DP[0xd3];
                                                     mon("         CLRA                          ; 0D9D: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         JSR   $0F2E                   ; 0D9E: BD 0F 2E      \n");
    memory[--S] = 0x0da1 & 0xff; memory[--S] = 0x0da1 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0DA1:                                       mon("L0DA1    LDA   #$80                    ; 0DA1: 86 80         \n");
    A = (UINT8)(SINT8)0x80;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$67                    ; 0DA3: 97 67         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x67] = A;
                                                     mon("         LDU   #$1A2D                  ; 0DA5: CE 1A 2D      \n");
    U = 0x1a2d;
    Z = U;
    N = (U) >> 8;
    V = 0;
                                                     mon("         JSR   Explosion_Snd           ; 0DA8: BD F9 2E      \n");
    memory[--S] = 0x0dab & 0xff; memory[--S] = 0x0dab >> 8;
    PC = 0xf92e;
    JUMP;
  case 0x0DAB:                                       mon("L0DAB    PULS  DP,PC                   ; 0DAB: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0DAD:                                       mon("L0DAD    LDB   <$D4                    ; 0DAD: D6 D4         \n");
    B = (UINT8)memory_DP[0xd4];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0DC2                   ; 0DAF: 27 11         \n");
    if (!Z) {
    PC = 0x0dc2;
    JUMP;
    }
                                                     mon("         CLR   <$D4                    ; 0DB1: 0F D4         \n");
    memory_DP[0xd4] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$77                    ; 0DB3: 0F 77         \n");
    memory_DP[0x77] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDU   #$1A31                  ; 0DB5: CE 1A 31      \n");
    U = 0x1a31;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   #$80                    ; 0DB8: 86 80         \n");
    A = (UINT8)(SINT8)0x80;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$67                    ; 0DBA: 97 67         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x67] = A;
                                                     mon("         JSR   $0F2E                   ; 0DBC: BD 0F 2E      \n");
    memory[--S] = 0x0dbf & 0xff; memory[--S] = 0x0dbf >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0DBF:                                       mon("L0DBF    JSR   Explosion_Snd           ; 0DBF: BD F9 2E      \n");
    memory[--S] = 0x0dc2 & 0xff; memory[--S] = 0x0dc2 >> 8;
    PC = 0xf92e;
    JUMP;
  case 0x0DC2:                                       mon("L0DC2    LDA   #$05                    ; 0DC2: 86 05         \n");
    A = (UINT8)(SINT8)0x05;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0DC4: BD 0F 2E      \n");
    memory[--S] = 0x0dc7 & 0xff; memory[--S] = 0x0dc7 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0DC7:                                       mon("L0DC7    LDB   <$ED                    ; 0DC7: D6 ED         \n");
    B = (UINT8)memory_DP[0xed];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BPL   $0DCC                   ; 0DC9: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0dcc;
    JUMP;
    }
                                                     mon("         NEGB                          ; 0DCB: 50            \n");
 // V = (UINT8)(-B) & (B);
 // C = (-B) & 0x100;
    B = (UINT8)(-B);
 // Z = B;
 // N = B;
  case 0x0DCC:                                       mon("L0DCC    ASLB                          ; 0DCC: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0DCD: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0DCE: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         SEX                           ; 0DCF: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         PSHS  B,A                     ; 0DD0: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         ASLB                          ; 0DD2: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 0DD3: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 0DD4: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 0DD5: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ASLB                          ; 0DD6: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 0DD7: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         PSHS  B,A                     ; 0DD8: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   #$0800                  ; 0DDA: CC 08 00      \n");
    A = (UINT8)((0x0800) >> 8);
    B = (UINT8)((0x0800) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  ,S++                    ; 0DDD: A3 E1         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STD   <$4B                    ; 0DDF: DD 4B         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x4b] = A;
    memory_DP[0x4b + 1] = B;
                                                     mon("         LDD   #$01B0                  ; 0DE1: CC 01 B0      \n");
    A = (UINT8)((0x01b0) >> 8);
    B = (UINT8)((0x01b0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  ,S++                    ; 0DE4: A3 E1         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STD   <$47                    ; 0DE6: DD 47         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x47] = A;
    memory_DP[0x47 + 1] = B;
                                                     mon("         LDD   #$080A                  ; 0DE8: CC 08 0A      \n");
    A = (UINT8)((0x080a) >> 8);
    B = (UINT8)((0x080a) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$42                    ; 0DEB: 97 42         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x42] = A;
                                                     mon("         STB   <$44                    ; 0DED: D7 44         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x44] = B;
                                                     mon("         LDA   <$26                    ; 0DEF: 96 26         \n");
    A = (UINT8)memory_DP[0x26];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 0DF1: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0DF2: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0DF3: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         NOP                           ; 0DF4: 12            \n");
                                                     mon("         NOP                           ; 0DF5: 12            \n");
                                                     mon("         ASRA                          ; 0DF6: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0DF7: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0DF8: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
    N = A;
                                                     mon("         BPL   $0DFC                   ; 0DF9: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0dfc;
    JUMP;
    }
                                                     mon("         NEGA                          ; 0DFB: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x0DFC:                                       mon("L0DFC    STA   <$46                    ; 0DFC: 97 46         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x46] = A;
                                                     mon("         LDA   #$DA                    ; 0DFE: 86 DA         \n");
    A = (UINT8)(SINT8)0xda;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  <$45                    ; 0E00: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0E02: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         LDB   <$D6                    ; 0E04: D6 D6         \n");
    B = (UINT8)memory_DP[0xd6];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0E32                   ; 0E06: 27 2A         \n");
    if (!Z) {
    PC = 0x0e32;
    JUMP;
    }
                                                     mon("         DEC   <$D6                    ; 0E08: 0A D6         \n");
    res = (UINT8)(memory_DP[0xd6] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd6] & ~res;
    memory_DP[0xd6] = res;
                                                     mon("         LDA   #$04                    ; 0E0A: 86 04         \n");
    A = (UINT8)(SINT8)0x04;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0E0C: BD 0F 2E      \n");
    memory[--S] = 0x0e0f & 0xff; memory[--S] = 0x0e0f >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0E0F:                                       mon("L0E0F    COMA                          ; 0E0F: 43            \n");
    A = A ^ 0xff;
 // Z = A;
 // N = A;
 // V = 0;
 // C = 256;
                                                     mon("         ANDA  <$45                    ; 0E10: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0E12: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         CMPB  #$1F                    ; 0E14: C1 1F         \n");
    res = B - (SINT8)0x1f;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x1f) & (B ^ (UINT8)res);
                                                     mon("         BNE   $0E1F                   ; 0E16: 26 07         \n");
    if (Z) {
    PC = 0x0e1f;
    JUMP;
    }
                                                     mon("         LDX   #$80                    ; 0E18: 8E 00 80      \n");
    X = 0x0080;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         STX   <$47                    ; 0E1B: 9F 47         \n");
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
    memory_DP[0x47] = (UINT8)((X) >> 8);
    memory_DP[(UINT16)(0x47 + 1)] = (X) & 0xff;
                                                     mon("         STX   <$DB                    ; 0E1D: 9F DB         \n");
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
    memory_DP[0xdb] = (UINT8)((X) >> 8);
    memory_DP[(UINT16)(0xdb + 1)] = (X) & 0xff;
  case 0x0E1F:                                       mon("L0E1F    LSRB                          ; 0E1F: 54            \n");
    C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         STB   <$42                    ; 0E20: D7 42         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x42] = B;
                                                     mon("         RORB                          ; 0E22: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
    C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         RORB                          ; 0E23: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         SEX                           ; 0E24: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ORA   #$01                    ; 0E25: 8A 01         \n");
    A = A | (SINT8)0x01;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ASLA                          ; 0E27: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0E28: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         TFR   A,B                     ; 0E29: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 0E2B: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$DB                    ; 0E2C: D3 DB         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0xdb]<<8)|memory_DP[0xdb + 1]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0xdb]<<8)|memory_DP[0xdb + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$DB                    ; 0E2E: DD DB         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xdb] = A;
    memory_DP[0xdb + 1] = B;
                                                     mon("         STD   <$47                    ; 0E30: DD 47         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x47] = A;
    memory_DP[0x47 + 1] = B;
  case 0x0E32:                                       mon("L0E32    LDB   <$D5                    ; 0E32: D6 D5         \n");
    B = (UINT8)memory_DP[0xd5];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0E51                   ; 0E34: 27 1B         \n");
    if (!Z) {
    PC = 0x0e51;
    JUMP;
    }
                                                     mon("         CLR   <$D5                    ; 0E36: 0F D5         \n");
    memory_DP[0xd5] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDA   #$04                    ; 0E38: 86 04         \n");
    A = (UINT8)(SINT8)0x04;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0E3A: BD 0F 2E      \n");
    memory[--S] = 0x0e3d & 0xff; memory[--S] = 0x0e3d >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0E3D:                                       mon("L0E3D    COMA                          ; 0E3D: 43            \n");
    A = A ^ 0xff;
 // Z = A;
 // N = A;
 // V = 0;
 // C = 256;
                                                     mon("         ANDA  <$45                    ; 0E3E: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0E40: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         LDD   #$0110                  ; 0E42: CC 01 10      \n");
    A = (UINT8)((0x0110) >> 8);
    B = (UINT8)((0x0110) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         TST   <$BD                    ; 0E45: 0D BD         \n");
 // Z = memory_DP[0xbd];
    N = memory_DP[0xbd];
 // V = 0;
                                                     mon("         BPL   $0E4B                   ; 0E47: 2A 02         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0e4b;
    JUMP;
    }
                                                     mon("         ASRA                          ; 0E49: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 0E4A: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
  case 0x0E4B:                                       mon("L0E4B    STD   <$47                    ; 0E4B: DD 47         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x47] = A;
    memory_DP[0x47 + 1] = B;
                                                     mon("         LDB   #$0F                    ; 0E4D: C6 0F         \n");
    B = (UINT8)(SINT8)0x0f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STB   <$42                    ; 0E4F: D7 42         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x42] = B;
  case 0x0E51:                                       mon("L0E51    LDB   <$D8                    ; 0E51: D6 D8         \n");
    B = (UINT8)memory_DP[0xd8];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BNE   $0E5D                   ; 0E53: 26 08         \n");
    if (Z) {
    PC = 0x0e5d;
    JUMP;
    }
                                                     mon("         LDA   <$BF                    ; 0E55: 96 BF         \n");
    A = (UINT8)memory_DP[0xbf];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $0E7D                   ; 0E57: 27 24         \n");
    if (!Z) {
    PC = 0x0e7d;
    JUMP;
    }
                                                     mon("         LDA   #$0F                    ; 0E59: 86 0F         \n");
    A = (UINT8)(SINT8)0x0f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$D8                    ; 0E5B: 97 D8         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xd8] = A;
  case 0x0E5D:                                       mon("L0E5D    LDA   #$05                    ; 0E5D: 86 05         \n");
    A = (UINT8)(SINT8)0x05;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0E5F: BD 0F 2E      \n");
    memory[--S] = 0x0e62 & 0xff; memory[--S] = 0x0e62 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0E62:                                       mon("L0E62    COMA                          ; 0E62: 43            \n");
    A = A ^ 0xff;
 // Z = A;
 // N = A;
 // V = 0;
 // C = 256;
                                                     mon("         ANDA  <$45                    ; 0E63: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0E65: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         DEC   <$D8                    ; 0E67: 0A D8         \n");
    res = (UINT8)(memory_DP[0xd8] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd8] & ~res;
    memory_DP[0xd8] = res;
                                                     mon("         ASLB                          ; 0E69: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0E6A: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0E6B: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         SEX                           ; 0E6C: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  #$80                    ; 0E6D: C3 00 80      \n");
    arg = (A << 8) | B;
    res = arg + 0x0080;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0080) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$4B                    ; 0E70: DD 4B         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x4b] = A;
    memory_DP[0x4b + 1] = B;
                                                     mon("         ADDD  #$20                    ; 0E72: C3 00 20      \n");
    arg = (A << 8) | B;
    res = arg + 0x0020;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0020) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$47                    ; 0E75: DD 47         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x47] = A;
    memory_DP[0x47 + 1] = B;
                                                     mon("         LDA   #$0D                    ; 0E77: 86 0D         \n");
    A = (UINT8)(SINT8)0x0d;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$44                    ; 0E79: 97 44         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x44] = A;
                                                     mon("         STA   <$42                    ; 0E7B: 97 42         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x42] = A;
  case 0x0E7D:                                       mon("L0E7D    LDB   <$77                    ; 0E7D: D6 77         \n");
    B = (UINT8)memory_DP[0x77];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0E85                   ; 0E7F: 27 04         \n");
    if (!Z) {
    PC = 0x0e85;
    JUMP;
    }
                                                     mon("         CLR   <$D7                    ; 0E81: 0F D7         \n");
    memory_DP[0xd7] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         BRA   $0EB0                   ; 0E83: 20 2B         \n");
    PC = 0x0eb0;
    JUMP;
    
  case 0x0E85:                                       mon("L0E85    LDB   <$D7                    ; 0E85: D6 D7         \n");
    B = (UINT8)memory_DP[0xd7];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0EB0                   ; 0E87: 27 27         \n");
    if (!Z) {
    PC = 0x0eb0;
    JUMP;
    }
                                                     mon("         LDA   #$02                    ; 0E89: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0E8B: BD 0F 2E      \n");
    memory[--S] = 0x0e8e & 0xff; memory[--S] = 0x0e8e >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0E8E:                                       mon("L0E8E    DEC   <$D7                    ; 0E8E: 0A D7         \n");
    res = (UINT8)(memory_DP[0xd7] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd7] & ~res;
    memory_DP[0xd7] = res;
                                                     mon("         CMPB  #$08                    ; 0E90: C1 08         \n");
    res = B - (SINT8)0x08;
 // C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
    V = (B ^ (SINT8)0x08) & (B ^ (UINT8)res);
                                                     mon("         BGE   $0E97                   ; 0E92: 2C 03         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x0e97;
    JUMP;
    }
                                                     mon("         ASLB                          ; 0E94: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
    Z = res;
    N = res;
    V = B ^ res;
    B = res;
                                                     mon("         BRA   $0E9D                   ; 0E95: 20 06         \n");
    PC = 0x0e9d;
    JUMP;
    
  case 0x0E97:                                       mon("L0E97    PSHS  B                       ; 0E97: 34 04         \n");
    memory[--S] = B;
                                                     mon("         LDB   #$17                    ; 0E99: C6 17         \n");
    B = (UINT8)(SINT8)0x17;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  ,S+                     ; 0E9B: E0 E0         \n");
    res = B - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[S]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
    S = S + 1;
  case 0x0E9D:                                       mon("L0E9D    SUBB  #$04                    ; 0E9D: C0 04         \n");
    res = B - (SINT8)0x04;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x04) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         BCC   $0EA2                   ; 0E9F: 24 01         \n");
    if (!C) {
    PC = 0x0ea2;
    JUMP;
    }
                                                     mon("         CLRB                          ; 0EA1: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x0EA2:                                       mon("L0EA2    STB   <$43                    ; 0EA2: D7 43         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x43] = B;
                                                     mon("         LDB   #$0F                    ; 0EA4: C6 0F         \n");
    B = (UINT8)(SINT8)0x0f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  <$43                    ; 0EA6: D0 43         \n");
    res = B - memory_DP[0x43];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0x43]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         STB   <$46                    ; 0EA8: D7 46         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x46] = B;
                                                     mon("         LDA   #$EF                    ; 0EAA: 86 EF         \n");
    A = (UINT8)(SINT8)0xef;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  <$45                    ; 0EAC: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0EAE: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
  case 0x0EB0:                                       mon("L0EB0    LDB   <$D9                    ; 0EB0: D6 D9         \n");
    B = (UINT8)memory_DP[0xd9];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0ED9                   ; 0EB2: 27 25         \n");
    if (!Z) {
    PC = 0x0ed9;
    JUMP;
    }
                                                     mon("         DEC   <$D9                    ; 0EB4: 0A D9         \n");
    res = (UINT8)(memory_DP[0xd9] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd9] & ~res;
    memory_DP[0xd9] = res;
                                                     mon("         LDA   #$80                    ; 0EB6: 86 80         \n");
    A = (UINT8)(SINT8)0x80;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $0F2E                   ; 0EB8: BD 0F 2E      \n");
    memory[--S] = 0x0ebb & 0xff; memory[--S] = 0x0ebb >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0EBB:                                       mon("L0EBB    CMPB  #$2F                    ; 0EBB: C1 2F         \n");
    res = B - (SINT8)0x2f;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x2f) & (B ^ (UINT8)res);
                                                     mon("         BLS   $0EC4                   ; 0EBD: 23 05         \n");
    if ((!Z) || C) {
    PC = 0x0ec4;
    JUMP;
    }
                                                     mon("         SUBB  #$4F                    ; 0EBF: C0 4F         \n");
    res = B - (SINT8)0x4f;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x4f) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         NEGB                          ; 0EC1: 50            \n");
    V = (UINT8)(-B) & (B);
    C = (-B) & 0x100;
    B = (UINT8)(-B);
    Z = B;
    N = B;
                                                     mon("         BRA   $0EC5                   ; 0EC2: 20 01         \n");
    PC = 0x0ec5;
    JUMP;
    
  case 0x0EC4:                                       mon("L0EC4    ASRB                          ; 0EC4: 57            \n");
 // C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
  case 0x0EC5:                                       mon("L0EC5    ASRB                          ; 0EC5: 57            \n");
    C = B & 1;
    B = (UINT8)((SINT8)B >> 1);
 // Z = B;
 // N = B;
                                                     mon("         STB   <$44                    ; 0EC6: D7 44         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x44] = B;
                                                     mon("         STB   <$43                    ; 0EC8: D7 43         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x43] = B;
                                                     mon("         STB   <$42                    ; 0ECA: D7 42         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x42] = B;
                                                     mon("         JSR   Random                  ; 0ECC: BD F5 17      \n");
    memory[--S] = 0x0ecf & 0xff; memory[--S] = 0x0ecf >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0ECF:                                       mon("L0ECF    ANDA  #$1F                    ; 0ECF: 84 1F         \n");
    A = A & (SINT8)0x1f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$46                    ; 0ED1: 97 46         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x46] = A;
                                                     mon("         LDB   #$C7                    ; 0ED3: C6 C7         \n");
    B = (UINT8)(SINT8)0xc7;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDB  <$45                    ; 0ED5: D4 45         \n");
    B = B & memory_DP[0x45];
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   <$45                    ; 0ED7: D7 45         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x45] = B;
  case 0x0ED9:                                       mon("L0ED9    LDB   <$CE                    ; 0ED9: D6 CE         \n");
    B = (UINT8)memory_DP[0xce];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0F16                   ; 0EDB: 27 39         \n");
    if (!Z) {
    PC = 0x0f16;
    JUMP;
    }
                                                     mon("         LDA   #$80                    ; 0EDD: 86 80         \n");
    A = (UINT8)(SINT8)0x80;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BSR   $0F2E                   ; 0EDF: 8D 4D         \n");
    memory[--S] = 0x0ee1 & 0xff; memory[--S] = 0x0ee1 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0EE1:                                       mon("L0EE1    JSR   Abs_b                   ; 0EE1: BD F5 8B      \n");
    memory[--S] = 0x0ee4 & 0xff; memory[--S] = 0x0ee4 >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x0EE4:                                       mon("L0EE4    PSHS  B                       ; 0EE4: 34 04         \n");
    memory[--S] = B;
                                                     mon("         SEX                           ; 0EE6: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         PSHS  B,A                     ; 0EE7: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         ADDD  #$80                    ; 0EE9: C3 00 80      \n");
    arg = (A << 8) | B;
    res = arg + 0x0080;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0080) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$4B                    ; 0EEC: DD 4B         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x4b] = A;
    memory_DP[0x4b + 1] = B;
                                                     mon("         ADDD  #$80                    ; 0EEE: C3 00 80      \n");
    arg = (A << 8) | B;
    res = arg + 0x0080;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0080) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   <$49                    ; 0EF1: DD 49         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x49] = A;
    memory_DP[0x49 + 1] = B;
                                                     mon("         LDD   #$0200                  ; 0EF3: CC 02 00      \n");
    A = (UINT8)((0x0200) >> 8);
    B = (UINT8)((0x0200) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  ,S++                    ; 0EF6: A3 E1         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STD   <$47                    ; 0EF8: DD 47         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x47] = A;
    memory_DP[0x47 + 1] = B;
                                                     mon("         PULS  A                       ; 0EFA: 35 02         \n");
    A = memory[S++];
                                                     mon("         ASRA                          ; 0EFC: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0EFD: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         ASRA                          ; 0EFE: 47            \n");
 // C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         CMPA  #$05                    ; 0EFF: 81 05         \n");
    res = A - (SINT8)0x05;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x05) & (A ^ (UINT8)res);
                                                     mon("         BCC   $0F05                   ; 0F01: 24 02         \n");
    if (!C) {
    PC = 0x0f05;
    JUMP;
    }
                                                     mon("         LDA   #$05                    ; 0F03: 86 05         \n");
    A = (UINT8)(SINT8)0x05;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x0F05:                                       mon("L0F05    STA   <$44                    ; 0F05: 97 44         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x44] = A;
                                                     mon("         STA   <$43                    ; 0F07: 97 43         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x43] = A;
                                                     mon("         STA   <$42                    ; 0F09: 97 42         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x42] = A;
                                                     mon("         JSR   Random                  ; 0F0B: BD F5 17      \n");
    memory[--S] = 0x0f0e & 0xff; memory[--S] = 0x0f0e >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0F0E:                                       mon("L0F0E    STA   <$46                    ; 0F0E: 97 46         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x46] = A;
                                                     mon("         LDA   #$E8                    ; 0F10: 86 E8         \n");
    A = (UINT8)(SINT8)0xe8;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  <$45                    ; 0F12: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0F14: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
  case 0x0F16:                                       mon("L0F16    LDB   <$DA                    ; 0F16: D6 DA         \n");
    B = (UINT8)memory_DP[0xda];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $0F2C                   ; 0F18: 27 12         \n");
    if (!Z) {
    PC = 0x0f2c;
    JUMP;
    }
                                                     mon("         DEC   <$DA                    ; 0F1A: 0A DA         \n");
    res = (UINT8)(memory_DP[0xda] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xda] & ~res;
    memory_DP[0xda] = res;
                                                     mon("         LDA   #$02                    ; 0F1C: 86 02         \n");
    A = (UINT8)(SINT8)0x02;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BSR   $0F2E                   ; 0F1E: 8D 0E         \n");
    memory[--S] = 0x0f20 & 0xff; memory[--S] = 0x0f20 >> 8;
    PC = 0x0f2e;
    JUMP;
  case 0x0F20:                                       mon("L0F20    COMA                          ; 0F20: 43            \n");
    A = A ^ 0xff;
 // Z = A;
 // N = A;
 // V = 0;
    C = 256;
                                                     mon("         ANDA  <$45                    ; 0F21: 94 45         \n");
    A = A & memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0F23: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         STB   <$43                    ; 0F25: D7 43         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x43] = B;
                                                     mon("         LDD   #$0500                  ; 0F27: CC 05 00      \n");
    A = (UINT8)((0x0500) >> 8);
    B = (UINT8)((0x0500) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$49                    ; 0F2A: DD 49         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0x49] = A;
    memory_DP[0x49 + 1] = B;
  case 0x0F2C:                                       mon("L0F2C    PULS  DP,PC                   ; 0F2C: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0F2E:                                       mon("L0F2E    PSHS  U,X,B,A                 ; 0F2E: 34 56         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         CLR   <$56                    ; 0F30: 0F 56         \n");
    memory_DP[0x56] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         TSTA                          ; 0F32: 4D            \n");
    Z = A;
    N = A;
 // V = 0;
                                                     mon("         BMI   $0F46                   ; 0F33: 2B 11         \n");
    if ((SINT8)N <  0) {
    PC = 0x0f46;
    JUMP;
    }
                                                     mon("         BNE   $0F4F                   ; 0F35: 26 18         \n");
    if (Z) {
    PC = 0x0f4f;
    JUMP;
    }
                                                     mon("         CLR   <$67                    ; 0F37: 0F 67         \n");
    memory_DP[0x67] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$56                    ; 0F39: 0F 56         \n");
    memory_DP[0x56] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLR   <$77                    ; 0F3B: 0F 77         \n");
    memory_DP[0x77] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         LDX   #$C8D5                  ; 0F3D: 8E C8 D5      \n");
    X = 0xc8d5;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$08                    ; 0F40: CC 00 08      \n");
    A = (UINT8)((0x0008) >> 8);
    B = (UINT8)((0x0008) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Clear_x_d               ; 0F43: BD F5 48      \n");
    memory[--S] = 0x0f46 & 0xff; memory[--S] = 0x0f46 >> 8;
    PC = 0xf548;
    JUMP;
  case 0x0F46:                                       mon("L0F46    LDA   <$77                    ; 0F46: 96 77         \n");
    A = (UINT8)memory_DP[0x77];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BNE   $0F4D                   ; 0F48: 26 03         \n");
    if (Z) {
    PC = 0x0f4d;
    JUMP;
    }
                                                     mon("         JSR   Init_Music_Buf          ; 0F4A: BD F5 33      \n");
    memory[--S] = 0x0f4d & 0xff; memory[--S] = 0x0f4d >> 8;
    PC = 0xf533;
    JUMP;
  case 0x0F4D:                                       mon("L0F4D    PULS  A,B,X,U,PC              ; 0F4D: 35 D6         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0F4F:                                       mon("L0F4F    ANDA  #$07                    ; 0F4F: 84 07         \n");
    A = A & (SINT8)0x07;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         TFR   A,B                     ; 0F51: 1F 89         \n");
    B = A;
                                                     mon("         PSHS  B,A                     ; 0F53: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         ASLA                          ; 0F55: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0F56: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0F57: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ORA   ,S+                     ; 0F58: AA E0         \n");
    A = A | memory[S];
 // Z = A;
 // N = A;
 // V = 0;
    S = S + 1;
                                                     mon("         ORA   <$45                    ; 0F5A: 9A 45         \n");
    A = A | memory_DP[0x45];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$45                    ; 0F5C: 97 45         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x45] = A;
                                                     mon("         LDX   #Vec_Music_Work         ; 0F5E: 8E C8 3F      \n");
    X = 0xc83f;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         CLR   ,X+                     ; 0F61: 6F 80         \n");
    memory[X] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
    X = X + 1;
                                                     mon("         CLR   ,X+                     ; 0F63: 6F 80         \n");
    memory[X] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
    X = X + 1;
                                                     mon("         CLR   ,X+                     ; 0F65: 6F 80         \n");
    memory[X] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
    X = X + 1;
                                                     mon("         CLR   <$46                    ; 0F67: 0F 46         \n");
    memory_DP[0x46] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDU   #Vec_Music_Wk_5         ; 0F69: CE C8 47      \n");
    U = 0xc847;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         PULS  A                       ; 0F6C: 35 02         \n");
    A = memory[S++];
                                                     mon("         LDB   #$02                    ; 0F6E: C6 02         \n");
    B = (UINT8)(SINT8)0x02;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x0F70:                                       mon("L0F70    LSRA                          ; 0F70: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         BCC   $0F7D                   ; 0F71: 24 0A         \n");
    if (!C) {
    PC = 0x0f7d;
    JUMP;
    }
                                                     mon("         CLR   B,X                     ; 0F73: 6F 85         \n");
    memory[(UINT16)(X + (SINT8)B)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         ASLB                          ; 0F75: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         CLR   B,U                     ; 0F76: 6F C5         \n");
    memory[(UINT16)(U + (SINT8)B)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         INCB                          ; 0F78: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
                                                     mon("         CLR   B,U                     ; 0F79: 6F C5         \n");
    memory[(UINT16)(U + (SINT8)B)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         DECB                          ; 0F7B: 5A            \n");
    res = (UINT8)(B - 1);
 // N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         LSRB                          ; 0F7C: 54            \n");
    C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
  case 0x0F7D:                                       mon("L0F7D    DECB                          ; 0F7D: 5A            \n");
    res = (UINT8)(B - 1);
    N = res;
    Z = res;
    V = B & ~res;
    B = res;
                                                     mon("         BPL   $0F70                   ; 0F7E: 2A F0         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0f70;
    JUMP;
    }
                                                     mon("         PULS  A,B,X,U,PC              ; 0F80: 35 D6         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0F82:                                       mon("L0F82    LDA   #$5F                    ; 0F82: 86 5F         \n");
    A = (UINT8)(SINT8)0x5f;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BRA   $0F88                   ; 0F84: 20 02         \n");
    PC = 0x0f88;
    JUMP;
    
  case 0x0F86:                                       mon("L0F86    LDA   #$7F                    ; 0F86: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x0F88:                                       mon("L0F88    LDB   $C8EB                   ; 0F88: F6 C8 EB      \n");
    B = (UINT8)memory[0xc8eb];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 0F8B: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 0F8C: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
    Z = (UINT8)res;
    N = (UINT8)res;
    H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         JMP   Intensity_a             ; 0F8E: 7E F2 AB      \n");
    PC = 0xf2ab;
    JUMP;
    
  case 0x0F91:                                       mon("L0F91    PSHS  DP                      ; 0F91: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_C8                ; 0F93: BD F1 AF      \n");
    memory[--S] = 0x0f96 & 0xff; memory[--S] = 0x0f96 >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x0F96:                                       mon("L0F96    LDA   <$DA                    ; 0F96: 96 DA         \n");
    A = (UINT8)memory_DP[0xda];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $0FF7                   ; 0F98: 26 5D         \n");
    if (Z) {
    PC = 0x0ff7;
    JUMP;
    }
                                                     mon("         LDA   $07,U                   ; 0F9A: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$02                    ; 0F9C: 81 02         \n");
    res = A - (SINT8)0x02;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x02) & (A ^ (UINT8)res);
                                                     mon("         BNE   $0FBC                   ; 0F9E: 26 1C         \n");
    if (Z) {
    PC = 0x0fbc;
    JUMP;
    }
                                                     mon("         LDB   <$ED                    ; 0FA0: D6 ED         \n");
    B = (UINT8)memory_DP[0xed];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Abs_b                   ; 0FA2: BD F5 8B      \n");
    memory[--S] = 0x0fa5 & 0xff; memory[--S] = 0x0fa5 >> 8;
    PC = 0xf58b;
    JUMP;
  case 0x0FA5:                                       mon("L0FA5    CMPB  #$04                    ; 0FA5: C1 04         \n");
    res = B - (SINT8)0x04;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
                                                     mon("         BCC   $0FB8                   ; 0FA7: 24 0F         \n");
    if (!C) {
    PC = 0x0fb8;
    JUMP;
    }
                                                     mon("         ASLB                          ; 0FA9: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0FAA: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0FAB: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0FAC: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0FAD: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 0FAE: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         PSHS  B                       ; 0FAF: 34 04         \n");
    memory[--S] = B;
                                                     mon("         JSR   Random                  ; 0FB1: BD F5 17      \n");
    memory[--S] = 0x0fb4 & 0xff; memory[--S] = 0x0fb4 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x0FB4:                                       mon("L0FB4    CMPA  ,S+                     ; 0FB4: A1 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ memory[S]) & (A ^ (UINT8)res);
    S = S + 1;
                                                     mon("         BCC   $0FBC                   ; 0FB6: 24 04         \n");
    if (!C) {
    PC = 0x0fbc;
    JUMP;
    }
  case 0x0FB8:                                       mon("L0FB8    LDA   #$99                    ; 0FB8: 86 99         \n");
    A = (UINT8)(SINT8)0x99;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BRA   $0FD1                   ; 0FBA: 20 15         \n");
    PC = 0x0fd1;
    JUMP;
    
  case 0x0FBC:                                       mon("L0FBC    LDD   <$ED                    ; 0FBC: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
    N = A;
 // V = 0;
                                                     mon("         BPL   $0FC3                   ; 0FBE: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x0fc3;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 0FC0: BD 19 CB      \n");
    memory[--S] = 0x0fc3 & 0xff; memory[--S] = 0x0fc3 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0FC3:                                       mon("L0FC3    ASLA                          ; 0FC3: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0FC4: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0FC5: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 0FC6: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         LSRA                          ; 0FC7: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRB                          ; 0FC8: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0FC9: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0FCA: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0FCB: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 0FCC: 54            \n");
    C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         PSHS  B                       ; 0FCD: 34 04         \n");
    memory[--S] = B;
                                                     mon("         ORA   ,S+                     ; 0FCF: AA E0         \n");
    A = A | memory[S];
 // Z = A;
 // N = A;
 // V = 0;
    S = S + 1;
  case 0x0FD1:                                       mon("L0FD1    LDB   <$DA                    ; 0FD1: D6 DA         \n");
    B = (UINT8)memory_DP[0xda];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BNE   $0FF7                   ; 0FD3: 26 22         \n");
    if (Z) {
    PC = 0x0ff7;
    JUMP;
    }
                                                     mon("         LDB   <$C7                    ; 0FD5: D6 C7         \n");
    B = (UINT8)memory_DP[0xc7];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ORB   <$C8                    ; 0FD7: DA C8         \n");
    B = B | memory_DP[0xc8];
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BNE   $0FF7                   ; 0FD9: 26 1C         \n");
    if (Z) {
    PC = 0x0ff7;
    JUMP;
    }
                                                     mon("         LDB   #$0F                    ; 0FDB: C6 0F         \n");
    B = (UINT8)(SINT8)0x0f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STB   <$DA                    ; 0FDD: D7 DA         \n");
    Z = B;
    N = B;
    V = 0;
    memory_DP[0xda] = B;
                                                     mon("         BRA   $0FE7                   ; 0FDF: 20 06         \n");
    PC = 0x0fe7;
    JUMP;
    
  case 0x0FE1:                                       mon("L0FE1    PSHS  DP                      ; 0FE1: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDB   #$C8                    ; 0FE3: C6 C8         \n");
    B = (UINT8)(SINT8)0xc8;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         TFR   B,DP                    ; 0FE5: 1F 9B         \n");
    DP = (B) << 8;
    memory_DP = &memory[DP];
  case 0x0FE7:                                       mon("L0FE7    ADDA  <$C0                    ; 0FE7: 9B C0         \n");
    res = A + memory_DP[0xc0];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory_DP[0xc0] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0xc0] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         DAA                           ; 0FE9: 19            \n");
    res = A;
    msn = res & 0xf0;
    lsn = res & 0x0f;
    res = res + (((lsn > 0x09) || (H & 0x10)) ? 0x06 : 0);
    res = res + (((msn > 0x80) && (lsn > 0x09)) || ((msn > 0x90) || (C != 0)) ? 0x60 : 0);
    C = C | (res & 0x100);
    res = (UINT8)res;
    A = res;
 // N = res;
 // Z = res;
 // V = 0;
                                                     mon("         BCC   $0FEE                   ; 0FEA: 24 02         \n");
    if (!C) {
    PC = 0x0fee;
    JUMP;
    }
                                                     mon("         LDA   #$99                    ; 0FEC: 86 99         \n");
    A = (UINT8)(SINT8)0x99;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x0FEE:                                       mon("L0FEE    STA   <$C0                    ; 0FEE: 97 C0         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc0] = A;
                                                     mon("         LDD   <$ED                    ; 0FF0: DC ED         \n");
    A = memory_DP[0xed];
    B = memory_DP[0xed + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $19CB                   ; 0FF2: BD 19 CB      \n");
    memory[--S] = 0x0ff5 & 0xff; memory[--S] = 0x0ff5 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x0FF5:                                       mon("L0FF5    STD   <$ED                    ; 0FF5: DD ED         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory_DP[0xed] = A;
    memory_DP[0xed + 1] = B;
  case 0x0FF7:                                       mon("L0FF7    PULS  DP,PC                   ; 0FF7: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x0FF9:                                       mon("L0FF9    LDX   #$F9D4                  ; 0FF9: 8E F9 D4      \n");
    X = 0xf9d4;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$5007                  ; 0FFC: CC 50 07      \n");
    A = (UINT8)((0x5007) >> 8);
    B = (UINT8)((0x5007) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x0FFF:                                       mon("L0FFF    PSHS  X,B,A                   ; 0FFF: 34 16         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         STA   $C8EA                   ; 1001: B7 C8 EA      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8ea] = A;
                                                     mon("         LDD   $02,S                   ; 1004: EC 62         \n");
    A = memory[(UINT16)(S + 0x0002)];
    B = memory[(UINT16)(((UINT16)(S + 0x0002))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   $C8E6                   ; 1006: FD C8 E6      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc8e6] = A;
    memory[0xc8e6 + 1] = B;
                                                     mon("         PULS  A,B                     ; 1009: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         DECB                          ; 100B: 5A            \n");
    res = (UINT8)(B - 1);
 // N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         MUL                           ; 100C: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADDD  ,S++                    ; 100D: E3 E1         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[S]<<8)|memory[(UINT16)((S)+1)]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[S]<<8)|memory[(UINT16)((S)+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
    S = S + 2;
                                                     mon("         STD   $C8E8                   ; 100F: FD C8 E8      \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[0xc8e8] = A;
    memory[0xc8e8 + 1] = B;
                                                     mon("         RTS                           ; 1012: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1013:                                       mon("L1013    LDD   ,U++                    ; 1013: EC C1         \n");
    A = memory[U];
    B = memory[(UINT16)((U)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    U = U + 2;
                                                     mon("         STD   Vec_Text_HW             ; 1015: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
  case 0x1018:                                       mon("L1018    LDD   ,U++                    ; 1018: EC C1         \n");
    A = memory[U];
    B = memory[(UINT16)((U)+1)];
    Z = A|B;
    N = A;
    V = 0;
    U = U + 2;
                                                     mon("         JSR   Moveto_d                ; 101A: BD F3 12      \n");
    memory[--S] = 0x101d & 0xff; memory[--S] = 0x101d >> 8;
    PC = 0xf312;
    JUMP;
  case 0x101D:                                       mon("L101D    BRA   $1033                   ; 101D: 20 14         \n");
    PC = 0x1033;
    JUMP;
    
  case 0x101F:                                       mon("L101F    BSR   $1026                   ; 101F: 8D 05         \n");
    memory[--S] = 0x1021 & 0xff; memory[--S] = 0x1021 >> 8;
    PC = 0x1026;
    JUMP;
  case 0x1021:                                       mon("L1021    LDA   ,U                      ; 1021: A6 C4         \n");
    A = (UINT8)memory[U];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BNE   $101F                   ; 1023: 26 FA         \n");
    if (Z) {
    PC = 0x101f;
    JUMP;
    }
                                                     mon("         RTS                           ; 1025: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1026:                                       mon("L1026    LDD   ,U++                    ; 1026: EC C1         \n");
    A = memory[U];
    B = memory[(UINT16)((U)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    U = U + 2;
                                                     mon("         STD   Vec_Text_HW             ; 1028: FD C8 2A      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc82a] = A;
    memory[0xc82a + 1] = B;
                                                     mon("         LDD   ,U++                    ; 102B: EC C1         \n");
    A = memory[U];
    B = memory[(UINT16)((U)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    U = U + 2;
                                                     mon("         JSR   $0B67                   ; 102D: BD 0B 67      \n");
    memory[--S] = 0x1030 & 0xff; memory[--S] = 0x1030 >> 8;
    PC = 0x0b67;
    JUMP;
  case 0x1030:                                       mon("L1030    JSR   Delay_1                 ; 1030: BD F5 75      \n");
    memory[--S] = 0x1033 & 0xff; memory[--S] = 0x1033 >> 8;
    PC = 0xf575;
    JUMP;
  case 0x1033:                                       mon("L1033    STU   Vec_Str_Ptr             ; 1033: FF C8 2C      \n");
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
    memory[0xc82c] = (UINT8)((U) >> 8);
    memory[(UINT16)(0xc82c + 1)] = (U) & 0xff;
                                                     mon("         CLR   ,-S                     ; 1036: 6F E2         \n");
    S = S - 1;
    memory[S] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDX   $C8E6                   ; 1038: BE C8 E6      \n");
    X = ((memory[0xc8e6]<<8)|memory[(UINT16)((0xc8e6)+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$1883                  ; 103B: CC 18 83      \n");
    A = (UINT8)((0x1883) >> 8);
    B = (UINT8)((0x1883) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CLR   <$01                    ; 103E: 0F 01         \n");
    memory_DP[0x01] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         STA   <$0B                    ; 1040: 97 0B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0b] = A;
  case 0x1042:                                       mon("L1042    STB   <$00                    ; 1042: D7 00         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x00] = B;
                                                     mon("         DEC   <$00                    ; 1044: 0A 00         \n");
    res = (UINT8)(memory_DP[0x00] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x00] & ~res;
    memory_DP[0x00] = res;
                                                     mon("         LDD   #$8081                  ; 1046: CC 80 81      \n");
    A = (UINT8)((0x8081) >> 8);
    B = (UINT8)((0x8081) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         NOP                           ; 1049: 12            \n");
                                                     mon("         INC   <$00                    ; 104A: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         STB   <$00                    ; 104C: D7 00         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x00] = B;
                                                     mon("         STA   <$00                    ; 104E: 97 00         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x00] = A;
                                                     mon("         JSR   Delay_RTS               ; 1050: BD F5 7D      \n");
    memory[--S] = 0x1053 & 0xff; memory[--S] = 0x1053 >> 8;
    PC = 0xf57d;
    JUMP;
  case 0x1053:                                       mon("L1053    INC   <$00                    ; 1053: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         LDA   Vec_Text_Width          ; 1055: B6 C8 2B      \n");
    A = (UINT8)memory[0xc82b];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$01                    ; 1058: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         LDD   #$0100                  ; 105A: CC 01 00      \n");
    A = (UINT8)((0x0100) >> 8);
    B = (UINT8)((0x0100) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         LDU   Vec_Str_Ptr             ; 105D: FE C8 2C      \n");
    U = ((memory[0xc82c]<<8)|memory[(UINT16)((0xc82c)+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         STA   <$00                    ; 1060: 97 00         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x00] = A;
                                                     mon("         BRA   $1068                   ; 1062: 20 04         \n");
    PC = 0x1068;
    JUMP;
    
  case 0x1064:                                       mon("L1064    LDA   A,X                     ; 1064: A6 86         \n");
    A = (UINT8)memory[(UINT16)(X + (SINT8)A)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0A                    ; 1066: 97 0A         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0a] = A;
  case 0x1068:                                       mon("L1068    LDA   ,U+                     ; 1068: A6 C0         \n");
    A = (UINT8)memory[U];
    N = A;
 // Z = A;
 // V = 0;
    U = U + 1;
                                                     mon("         BPL   $1064                   ; 106A: 2A F8         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1064;
    JUMP;
    }
                                                     mon("         LDA   #$81                    ; 106C: 86 81         \n");
    A = (UINT8)(SINT8)0x81;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$00                    ; 106E: 97 00         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x00] = A;
                                                     mon("         LDA   <$0D                    ; 1070: 96 0D         \n");
    A = (UINT8)memory_DP[0x0d];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$02                    ; 1072: 84 02         \n");
    A = A & (SINT8)0x02;
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $1078                   ; 1074: 27 02         \n");
    if (!Z) {
    PC = 0x1078;
    JUMP;
    }
                                                     mon("         STA   ,S                      ; 1076: A7 E4         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[S] = A;
  case 0x1078:                                       mon("L1078    NEG   <$01                    ; 1078: 00 01         \n");
 // V = (UINT8)(-memory_DP[0x01]) & (memory_DP[0x01]);
 // C = (-memory_DP[0x01]) & 0x100;
    memory_DP[0x01] = (UINT8)(-memory_DP[0x01]);
 // Z = memory_DP[0x01];
 // N = memory_DP[0x01];
                                                     mon("         LDB   $C8EA                   ; 107A: F6 C8 EA      \n");
    B = (UINT8)memory[0xc8ea];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   #$01                    ; 107D: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$00                    ; 107F: 97 00         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x00] = A;
                                                     mon("         CPX   $C8E8                   ; 1081: BC C8 E8      \n");
    res = (X) - (((memory[0xc8e8]<<8)|memory[(UINT16)((0xc8e8)+1)]));
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((X) ^ (((memory[0xc8e8]<<8)|memory[(UINT16)((0xc8e8)+1)]))) & ((X) ^ res)) >> 8;
                                                     mon("         BCC   $10AF                   ; 1084: 24 29         \n");
    if (!C) {
    PC = 0x10af;
    JUMP;
    }
                                                     mon("         LEAX  B,X                     ; 1086: 30 85         \n");
    X = (X + (SINT8)B);
 // Z = X;
                                                     mon("         TFR   U,D                     ; 1088: 1F 30         \n");
    A = (UINT8)((U) >> 8);
    B = (UINT8)((U) & 0xff);
                                                     mon("         SUBD  Vec_Str_Ptr             ; 108A: B3 C8 2C      \n");
    arg = (A << 8) | B;
    res = arg - (((memory[0xc82c]<<8)|memory[(UINT16)((0xc82c)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[0xc82c]<<8)|memory[(UINT16)((0xc82c)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         SUBB  #$02                    ; 108D: C0 02         \n");
    res = B - (SINT8)0x02;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x02) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ASLB                          ; 108F: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
  case 0x1090:                                       mon("L1090    LDA   #$81                    ; 1090: 86 81         \n");
    A = (UINT8)(SINT8)0x81;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         NOP                           ; 1092: 12            \n");
                                                     mon("         DECB                          ; 1093: 5A            \n");
    res = (UINT8)(B - 1);
 // N = res;
    Z = res;
 // V = B & ~res;
    B = res;
                                                     mon("         BNE   $1090                   ; 1094: 26 FA         \n");
    if (Z) {
    PC = 0x1090;
    JUMP;
    }
                                                     mon("         STA   <$00                    ; 1096: 97 00         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x00] = A;
                                                     mon("         LDB   Vec_Text_HW             ; 1098: F6 C8 2A      \n");
    B = (UINT8)memory[0xc82a];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ASLB                          ; 109B: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 109C: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         STB   <$01                    ; 109D: D7 01         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x01] = B;
                                                     mon("         DEC   <$00                    ; 109F: 0A 00         \n");
    res = (UINT8)(memory_DP[0x00] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x00] & ~res;
    memory_DP[0x00] = res;
                                                     mon("         LDB   #$01                    ; 10A1: C6 01         \n");
    B = (UINT8)(SINT8)0x01;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         INC   <$00                    ; 10A3: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         CLR   <$01                    ; 10A5: 0F 01         \n");
    memory_DP[0x01] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         STB   <$00                    ; 10A7: D7 00         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x00] = B;
                                                     mon("         LDB   #$83                    ; 10A9: C6 83         \n");
    B = (UINT8)(SINT8)0x83;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STA   <$00                    ; 10AB: 97 00         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x00] = A;
                                                     mon("         BRA   $1042                   ; 10AD: 20 93         \n");
    PC = 0x1042;
    JUMP;
    
  case 0x10AF:                                       mon("L10AF    LDA   #$98                    ; 10AF: 86 98         \n");
    A = (UINT8)(SINT8)0x98;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0B                    ; 10B1: 97 0B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0b] = A;
                                                     mon("         JSR   Reset0Ref               ; 10B3: BD F3 54      \n");
    memory[--S] = 0x10b6 & 0xff; memory[--S] = 0x10b6 >> 8;
    PC = 0xf354;
    JUMP;
  case 0x10B6:                                       mon("L10B6    LDA   ,S+                     ; 10B6: A6 E0         \n");
    A = (UINT8)memory[S];
    N = A;
    Z = A;
    V = 0;
    S = S + 1;
                                                     mon("         RTS                           ; 10B8: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x10B9:                                       mon("L10B9    PSHS  U,X,DP,B,A              ; 10B9: 34 5E         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = (DP >> 8);
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         JSR   DP_to_C8                ; 10BB: BD F1 AF      \n");
    memory[--S] = 0x10be & 0xff; memory[--S] = 0x10be >> 8;
    PC = 0xf1af;
    JUMP;
  case 0x10BE:                                       mon("L10BE    LDX   #$CA28                  ; 10BE: 8E CA 28      \n");
    X = 0xca28;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDD   #$23                    ; 10C1: CC 00 23      \n");
    A = (UINT8)((0x0023) >> 8);
    B = (UINT8)((0x0023) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Clear_x_d               ; 10C4: BD F5 48      \n");
    memory[--S] = 0x10c7 & 0xff; memory[--S] = 0x10c7 >> 8;
    PC = 0xf548;
    JUMP;
  case 0x10C7:                                       mon("L10C7    LDU   #$C900                  ; 10C7: CE C9 00      \n");
    U = 0xc900;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         STU   <$DF                    ; 10CA: DF DF         \n");
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
    memory_DP[0xdf] = (UINT8)((U) >> 8);
    memory_DP[(UINT16)(0xdf + 1)] = (U) & 0xff;
  case 0x10CC:                                       mon("L10CC    TFR   U,X                     ; 10CC: 1F 31         \n");
    X = U;
                                                     mon("         LDB   #$10                    ; 10CE: C6 10         \n");
    B = (UINT8)(SINT8)0x10;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Clear_x_b               ; 10D0: BD F5 3F      \n");
    memory[--S] = 0x10d3 & 0xff; memory[--S] = 0x10d3 >> 8;
    PC = 0xf53f;
    JUMP;
  case 0x10D3:                                       mon("L10D3    LDA   #$FF                    ; 10D3: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $07,U                   ; 10D5: A7 47         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0007)] = A;
                                                     mon("         LEAU  $10,U                   ; 10D7: 33 C8 10      \n");
    U = (U + (SINT8)0x10);
                                                     mon("         CMPU  #$C9F0                  ; 10DA: 11 83 C9 F0   \n");
    res = (U) - (0xc9f0);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = (((U) ^ (0xc9f0)) & ((U) ^ res)) >> 8;
                                                     mon("         BCC   $10E4                   ; 10DE: 24 04         \n");
    if (!C) {
    PC = 0x10e4;
    JUMP;
    }
                                                     mon("         STU   $0E,X                   ; 10E0: EF 0E         \n");
    Z = U;
    N = (U) >> 8;
    V = 0;
    memory[(UINT16)(X + 0x000e)] = (UINT8)((U) >> 8);
    memory[(UINT16)((X + 0x000e) + 1)] = (U) & 0xff;
                                                     mon("         BRA   $10CC                   ; 10E2: 20 E8         \n");
    PC = 0x10cc;
    JUMP;
    
  case 0x10E4:                                       mon("L10E4    LDU   #$FFFF                  ; 10E4: CE FF FF      \n");
    U = 0xffff;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         STU   $0E,X                   ; 10E7: EF 0E         \n");
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
    memory[(UINT16)(X + 0x000e)] = (UINT8)((U) >> 8);
    memory[(UINT16)((X + 0x000e) + 1)] = (U) & 0xff;
                                                     mon("         LDX   #$CA4B                  ; 10E9: 8E CA 4B      \n");
    X = 0xca4b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   #$1AF6                  ; 10EC: CE 1A F6      \n");
    U = 0x1af6;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   #$05                    ; 10EF: 86 05         \n");
    A = (UINT8)(SINT8)0x05;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         JSR   Move_Mem_a              ; 10F1: BD F6 83      \n");
    memory[--S] = 0x10f4 & 0xff; memory[--S] = 0x10f4 >> 8;
    PC = 0xf683;
    JUMP;
  case 0x10F4:                                       mon("L10F4    PULS  A,B,DP,X,U,PC           ; 10F4: 35 DE         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x10F6:                                       mon("L10F6    JSR   Random                  ; 10F6: BD F5 17      \n");
    memory[--S] = 0x10f9 & 0xff; memory[--S] = 0x10f9 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x10F9:                                       mon("L10F9    TFR   A,B                     ; 10F9: 1F 89         \n");
    B = A;
                                                     mon("         RTS                           ; 10FB: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x10FC:                                       mon("L10FC    LDD   #$7F01                  ; 10FC: CC 7F 01      \n");
    A = (UINT8)((0x7f01) >> 8);
    B = (UINT8)((0x7f01) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STB   <$9E                    ; 10FF: D7 9E         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x9e] = B;
                                                     mon("         LDB   <$86                    ; 1101: D6 86         \n");
    B = (UINT8)memory_DP[0x86];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         TST   <$C7                    ; 1103: 0D C7         \n");
    Z = memory_DP[0xc7];
 // N = memory_DP[0xc7];
 // V = 0;
                                                     mon("         BNE   $1109                   ; 1105: 26 02         \n");
    if (Z) {
    PC = 0x1109;
    JUMP;
    }
                                                     mon("         ADDB  #$20                    ; 1107: CB 20         \n");
    res = B + (SINT8)0x20;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    B = (UINT8)res;
  case 0x1109:                                       mon("L1109    ANDB  #$3F                    ; 1109: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         JSR   Rise_Run_Y              ; 110B: BD F6 01      \n");
    memory[--S] = 0x110e & 0xff; memory[--S] = 0x110e >> 8;
    PC = 0xf601;
    JUMP;
  case 0x110E:                                       mon("L110E    LDX   #$C880                  ; 110E: 8E C8 80      \n");
    X = 0xc880;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         EXG   A,B                     ; 1111: 1E 89         \n");
    val = A;
    A = B;
    B = val;
                                                     mon("         PSHS  U,B,A                   ; 1113: 34 46         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = B;
    memory[--S] = A;
  case 0x1115:                                       mon("L1115    LDB   <$9E                    ; 1115: D6 9E         \n");
    B = (UINT8)memory_DP[0x9e];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDB   B,S                     ; 1117: E6 E5         \n");
    B = (UINT8)memory[(UINT16)(S + (SINT8)B)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 1119: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ASLB                          ; 111A: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ROLA                          ; 111B: 49            \n");
    res = ((A) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (A);
    A = (UINT8)res;
                                                     mon("         ADDD  ,X++                    ; 111C: E3 81         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[X]<<8)|memory[(UINT16)((X)+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
    X = X + 2;
                                                     mon("         STD   ,U                      ; 111E: ED C4         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[U] = A;
    memory[U + 1] = B;
                                                     mon("         JSR   Random                  ; 1120: BD F5 17      \n");
    memory[--S] = 0x1123 & 0xff; memory[--S] = 0x1123 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x1123:                                       mon("L1123    LDB   #$46                    ; 1123: C6 46         \n");
    B = (UINT8)(SINT8)0x46;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 1125: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 1126: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         TFR   A,B                     ; 1128: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 112A: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  ,U                      ; 112B: E3 C4         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[U]<<8)|memory[(UINT16)((U)+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[U]<<8)|memory[(UINT16)((U)+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   ,U++                    ; 112D: ED C1         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[U] = A;
    memory[U + 1] = B;
    U = U + 2;
                                                     mon("         LEAX  $02,X                   ; 112F: 30 02         \n");
    X = (X + 0x0002);
 // Z = X;
                                                     mon("         LEAU  $02,U                   ; 1131: 33 42         \n");
    U = (U + 0x0002);
                                                     mon("         DEC   <$9E                    ; 1133: 0A 9E         \n");
    res = (UINT8)(memory_DP[0x9e] - 1);
    N = res;
 // Z = res;
 // V = memory_DP[0x9e] & ~res;
    memory_DP[0x9e] = res;
                                                     mon("         BPL   $1115                   ; 1135: 2A DE         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1115;
    JUMP;
    }
                                                     mon("         PULS  A,B,U                   ; 1137: 35 46         \n");
    A = memory[S++];
    B = memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
                                                     mon("         JSR   Random                  ; 1139: BD F5 17      \n");
    memory[--S] = 0x113c & 0xff; memory[--S] = 0x113c >> 8;
    PC = 0xf517;
    JUMP;
  case 0x113C:                                       mon("L113C    LDB   #$14                    ; 113C: C6 14         \n");
    B = (UINT8)(SINT8)0x14;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 113E: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 113F: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         TFR   A,B                     ; 1141: 1F 89         \n");
    B = A;
                                                     mon("         SEX                           ; 1143: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  <$82                    ; 1144: D3 82         \n");
    arg = (A << 8) | B;
    res = arg + ((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory_DP[0x82]<<8)|memory_DP[0x82 + 1])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 1146: ED 42         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
                                                     mon("         RTS                           ; 1148: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1149:                                       mon("L1149    PSHS  Y,X,B,A                 ; 1149: 34 36         \n");
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDB   <$C7                    ; 114B: D6 C7         \n");
    B = (UINT8)memory_DP[0xc7];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $1153                   ; 114D: 27 04         \n");
    if (!Z) {
    PC = 0x1153;
    JUMP;
    }
                                                     mon("         LDB   <$C8                    ; 114F: D6 C8         \n");
    B = (UINT8)memory_DP[0xc8];
    N = B;
 // Z = B;
    V = 0;
                                                     mon("         BGE   $118E                   ; 1151: 2C 3B         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x118e;
    JUMP;
    }
  case 0x1153:                                       mon("L1153    LDB   <$CE                    ; 1153: D6 CE         \n");
    B = (UINT8)memory_DP[0xce];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BNE   $118E                   ; 1155: 26 37         \n");
    if (Z) {
    PC = 0x118e;
    JUMP;
    }
                                                     mon("         LDX   #$CA4B                  ; 1157: 8E CA 4B      \n");
    X = 0xca4b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   A,X                     ; 115A: E6 86         \n");
    B = (UINT8)memory[(UINT16)(X + (SINT8)A)];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $118E                   ; 115C: 27 30         \n");
    if (!Z) {
    PC = 0x118e;
    JUMP;
    }
                                                     mon("         LDU   <$DF                    ; 115E: DE DF         \n");
    U = ((memory_DP[0xdf]<<8)|memory_DP[0xdf + 1]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         CMPU  #$FFFF                  ; 1160: 11 83 FF FF   \n");
    res = (U) - (0xffff);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = (((U) ^ (0xffff)) & ((U) ^ res)) >> 8;
                                                     mon("         BEQ   $118E                   ; 1164: 27 28         \n");
    if (!Z) {
    PC = 0x118e;
    JUMP;
    }
                                                     mon("         LDD   $0E,U                   ; 1166: EC 4E         \n");
    A = memory[(UINT16)(U + 0x000e)];
    B = memory[(UINT16)(((UINT16)(U + 0x000e))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STD   <$DF                    ; 1168: DD DF         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xdf] = A;
    memory_DP[0xdf + 1] = B;
                                                     mon("         PULS  A,B                     ; 116A: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         STA   $07,U                   ; 116C: A7 47         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0007)] = A;
                                                     mon("         DEC   A,X                     ; 116E: 6A 86         \n");
    res = (UINT8)(memory[(UINT16)(X + (SINT8)A)] - 1);
 // N = res;
 // Z = res;
 // V = memory[(UINT16)(X + (SINT8)A)] & ~res;
    memory[(UINT16)(X + (SINT8)A)] = res;
                                                     mon("         LDX   #$1AD8                  ; 1170: 8E 1A D8      \n");
    X = 0x1ad8;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         ASLA                          ; 1173: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 1174: 48            \n");
    res = A << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         LDX   A,X                     ; 1175: AE 86         \n");
    X = ((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(X + (SINT8)A))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   ,X                      ; 1177: E6 84         \n");
    B = (UINT8)memory[X];
    N = B;
    Z = B;
    V = 0;
                                                     mon("         BSR   $1192                   ; 1179: 8D 17         \n");
    memory[--S] = 0x117b & 0xff; memory[--S] = 0x117b >> 8;
    PC = 0x1192;
    JUMP;
  case 0x117B:                                       mon("L117B    STB   $0C,U                   ; 117B: E7 4C         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x000c)] = B;
                                                     mon("         LDY   #$F9DC                  ; 117D: 10 8E F9 DC   \n");
    Y = 0xf9dc;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDA   B,Y                     ; 1181: A6 A5         \n");
    A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   ,X                      ; 1183: AA 84         \n");
    A = A | memory[X];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   ,X+                     ; 1185: A7 80         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[X] = A;
    X = X + 1;
                                                     mon("         ASLB                          ; 1187: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         STU   B,X                     ; 1188: EF 85         \n");
    Z = U;
    N = (U) >> 8;
    V = 0;
    memory[(UINT16)(X + (SINT8)B)] = (UINT8)((U) >> 8);
    memory[(UINT16)((X + (SINT8)B) + 1)] = (U) & 0xff;
                                                     mon("         ANDCC #$FE                    ; 118A: 1C FE         \n");
    C = 0;
                                                     mon("         PULS  X,Y,PC                  ; 118C: 35 B0         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    Y = memory[S++]<<8;
    Y |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x118E:                                       mon("L118E    ORCC  #$01                    ; 118E: 1A 01         \n");
    C = 1;
                                                     mon("         PULS  A,B,X,Y,PC              ; 1190: 35 B6         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    Y = memory[S++]<<8;
    Y |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1192:                                       mon("L1192    PSHS  A                       ; 1192: 34 02         \n");
    memory[--S] = A;
                                                     mon("         CLRA                          ; 1194: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x1195:                                       mon("L1195    LSRB                          ; 1195: 54            \n");
    C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         BCC   $119B                   ; 1196: 24 03         \n");
    if (!C) {
    PC = 0x119b;
    JUMP;
    }
                                                     mon("         INCA                          ; 1198: 4C            \n");
    res = (UINT8)(A + 1);
    Z = res;
    N = res;
    V = res & ~(A);
    A = res;
                                                     mon("         BRA   $1195                   ; 1199: 20 FA         \n");
    PC = 0x1195;
    JUMP;
    
  case 0x119B:                                       mon("L119B    TFR   A,B                     ; 119B: 1F 89         \n");
    B = A;
                                                     mon("         PULS  A,PC                    ; 119D: 35 82         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x119F:                                       mon("L119F    PSHS  Y,X,B,A                 ; 119F: 34 36         \n");
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   <$C7                    ; 11A1: DC C7         \n");
    A = memory_DP[0xc7];
    B = memory_DP[0xc7 + 1];
    Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         BNE   $11CE                   ; 11A3: 26 29         \n");
    if (Z) {
    PC = 0x11ce;
    JUMP;
    }
                                                     mon("         CLR   $0D,U                   ; 11A5: 6F 4D         \n");
    memory[(UINT16)(U + 0x000d)] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDA   $07,U                   ; 11A7: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDX   #$CA4B                  ; 11A9: 8E CA 4B      \n");
    X = 0xca4b;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         INC   A,X                     ; 11AC: 6C 86         \n");
    res = (UINT8)(memory[(UINT16)(X + (SINT8)A)] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory[(UINT16)(X + (SINT8)A)]);
    memory[(UINT16)(X + (SINT8)A)] = res;
                                                     mon("         ASLA                          ; 11AE: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         ASLA                          ; 11AF: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         LDX   #$1AD8                  ; 11B0: 8E 1A D8      \n");
    X = 0x1ad8;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDX   A,X                     ; 11B3: AE 86         \n");
    X = ((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(X + (SINT8)A))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDY   #$F9DC                  ; 11B5: 10 8E F9 DC   \n");
    Y = 0xf9dc;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDB   $0C,U                   ; 11B9: E6 4C         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000c)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDB   B,Y                     ; 11BB: E6 A5         \n");
    B = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         COMB                          ; 11BD: 53            \n");
    B = B ^ 0xff;
 // Z = B;
 // N = B;
 // V = 0;
    C = 256;
                                                     mon("         ANDB  ,X                      ; 11BE: E4 84         \n");
    B = B & memory[X];
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   ,X                      ; 11C0: E7 84         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[X] = B;
                                                     mon("         LDA   #$FF                    ; 11C2: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $07,U                   ; 11C4: A7 47         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0007)] = A;
                                                     mon("         STA   $0C,U                   ; 11C6: A7 4C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000c)] = A;
                                                     mon("         LDD   <$DF                    ; 11C8: DC DF         \n");
    A = memory_DP[0xdf];
    B = memory_DP[0xdf + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STU   <$DF                    ; 11CA: DF DF         \n");
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
    memory_DP[0xdf] = (UINT8)((U) >> 8);
    memory_DP[(UINT16)(0xdf + 1)] = (U) & 0xff;
                                                     mon("         STD   $0E,U                   ; 11CC: ED 4E         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x000e)] = A;
    memory[(UINT16)(U + 0x000e) + 1] = B;
  case 0x11CE:                                       mon("L11CE    PULS  A,B,X,Y,PC              ; 11CE: 35 B6         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    Y = memory[S++]<<8;
    Y |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         JSR   $139C                   ; 11D0: BD 13 9C      \n");
    memory[--S] = 0x11d3 & 0xff; memory[--S] = 0x11d3 >> 8;
    PC = 0x139c;
    JUMP;
  case 0x11D3:                                       mon("L11D3    LDA   $0D,U                   ; 11D3: A6 4D         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000d)];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         LBNE  $140F                   ; 11D5: 10 26 02 36   \n");
    if (Z) {
    PC = 0x140f;
    JUMP;
    }
  case 0x11D9:                                       mon("L11D9    JSR   $1314                   ; 11D9: BD 13 14      \n");
    memory[--S] = 0x11dc & 0xff; memory[--S] = 0x11dc >> 8;
    PC = 0x1314;
    JUMP;
  case 0x11DC:                                       mon("L11DC    ANDCC #$FD                    ; 11DC: 1C FD         \n");
    V = 0;
                                                     mon("         BCC   $11E7                   ; 11DE: 24 07         \n");
    if (!C) {
    PC = 0x11e7;
    JUMP;
    }
                                                     mon("         JSR   $1320                   ; 11E0: BD 13 20      \n");
    memory[--S] = 0x11e3 & 0xff; memory[--S] = 0x11e3 >> 8;
    PC = 0x1320;
    JUMP;
  case 0x11E3:                                       mon("L11E3    ORCC  #$01                    ; 11E3: 1A 01         \n");
    C = 1;
                                                     mon("         BVC   $11E8                   ; 11E5: 28 01         \n");
    if ((SINT8)V >= 0) {
    PC = 0x11e8;
    JUMP;
    }
  case 0x11E7:                                       mon("L11E7    RTS                           ; 11E7: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x11E8:                                       mon("L11E8    PSHS  DP                      ; 11E8: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         JSR   DP_to_D0                ; 11EA: BD F1 AA      \n");
    memory[--S] = 0x11ed & 0xff; memory[--S] = 0x11ed >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x11ED:                                       mon("L11ED    LDA   #$7F                    ; 11ED: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8BA                   ; 11EF: B0 C8 BA      \n");
    res = A - memory[0xc8ba];
 // C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
 // V = ((A) ^ memory[0xc8ba]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         JSR   $0F88                   ; 11F2: BD 0F 88      \n");
    memory[--S] = 0x11f5 & 0xff; memory[--S] = 0x11f5 >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x11F5:                                       mon("L11F5    JSR   [,X++]                  ; 11F5: AD 91         \n");
    memory[--S] = 0x11f7 & 0xff; memory[--S] = 0x11f7 >> 8;
    PC = ((memory[X]<<8)|memory[(UINT16)((X)+1)]);
    X = X + 2;
    JUMP;
  case 0x11F7:                                       mon("L11F7    ANDCC #$FD                    ; 11F7: 1C FD         \n");
    V = 0;
                                                     mon("         ORCC  #$01                    ; 11F9: 1A 01         \n");
    C = 1;
                                                     mon("         PULS  DP,PC                   ; 11FB: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x11FD:                                       mon("L11FD    PSHS  U,Y,X,B,A               ; 11FD: 34 76         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDA   ,X                      ; 11FF: A6 84         \n");
    A = (UINT8)memory[X];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $1213                   ; 1201: 27 10         \n");
    if (!Z) {
    PC = 0x1213;
    JUMP;
    }
                                                     mon("         LDB   ,U                      ; 1203: E6 C4         \n");
    B = (UINT8)memory[U];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $1213                   ; 1205: 27 0C         \n");
    if (!Z) {
    PC = 0x1213;
    JUMP;
    }
                                                     mon("         STD   <$97                    ; 1207: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDA   #$FF                    ; 1209: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$9C                    ; 120B: 97 9C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9c] = A;
                                                     mon("         STA   <$9D                    ; 120D: 97 9D         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9d] = A;
  case 0x120F:                                       mon("L120F    TST   <$97                    ; 120F: 0D 97         \n");
    Z = memory_DP[0x97];
    N = memory_DP[0x97];
    V = 0;
                                                     mon("         BNE   $1215                   ; 1211: 26 02         \n");
    if (Z) {
    PC = 0x1215;
    JUMP;
    }
  case 0x1213:                                       mon("L1213    PULS  A,B,X,Y,U,PC            ; 1213: 35 F6         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    Y = memory[S++]<<8;
    Y |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1215:                                       mon("L1215    INC   <$9C                    ; 1215: 0C 9C         \n");
    res = (UINT8)(memory_DP[0x9c] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9c]);
    memory_DP[0x9c] = res;
                                                     mon("         LSR   <$97                    ; 1217: 04 97         \n");
    C = (memory_DP[0x97]) & 1;
    memory_DP[0x97] = (memory_DP[0x97]) >> 1;
 // N = 0;
 // Z = memory_DP[0x97];
                                                     mon("         BCC   $120F                   ; 1219: 24 F4         \n");
    if (!C) {
    PC = 0x120f;
    JUMP;
    }
  case 0x121B:                                       mon("L121B    TST   <$98                    ; 121B: 0D 98         \n");
    Z = memory_DP[0x98];
 // N = memory_DP[0x98];
 // V = 0;
                                                     mon("         BNE   $122B                   ; 121D: 26 0C         \n");
    if (Z) {
    PC = 0x122b;
    JUMP;
    }
                                                     mon("         LDU   $06,S                   ; 121F: EE 66         \n");
    U = ((memory[(UINT16)(S + 0x0006)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0006))+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   ,U                      ; 1221: A6 C4         \n");
    A = (UINT8)memory[U];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$98                    ; 1223: 97 98         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x98] = A;
                                                     mon("         LDA   #$FF                    ; 1225: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$9D                    ; 1227: 97 9D         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x9d] = A;
                                                     mon("         BRA   $120F                   ; 1229: 20 E4         \n");
    PC = 0x120f;
    JUMP;
    
  case 0x122B:                                       mon("L122B    INC   <$9D                    ; 122B: 0C 9D         \n");
    res = (UINT8)(memory_DP[0x9d] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x9d]);
    memory_DP[0x9d] = res;
                                                     mon("         LSR   <$98                    ; 122D: 04 98         \n");
    C = (memory_DP[0x98]) & 1;
    memory_DP[0x98] = (memory_DP[0x98]) >> 1;
 // N = 0;
 // Z = memory_DP[0x98];
                                                     mon("         BCC   $121B                   ; 122F: 24 EA         \n");
    if (!C) {
    PC = 0x121b;
    JUMP;
    }
                                                     mon("         LDD   <$9C                    ; 1231: DC 9C         \n");
    A = memory_DP[0x9c];
    B = memory_DP[0x9c + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         ASLA                          ; 1233: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         INCA                          ; 1234: 4C            \n");
    res = (UINT8)(A + 1);
 // Z = res;
 // N = res;
 // V = res & ~(A);
    A = res;
                                                     mon("         ASLB                          ; 1235: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         INCB                          ; 1236: 5C            \n");
    res = (UINT8)(B + 1);
 // Z = res;
 // N = res;
 // V = res & ~(B);
    B = res;
                                                     mon("         LDX   $02,S                   ; 1237: AE 62         \n");
    X = ((memory[(UINT16)(S + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0002))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDX   A,X                     ; 1239: AE 86         \n");
    X = ((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(X + (SINT8)A))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDU   $06,S                   ; 123B: EE 66         \n");
    U = ((memory[(UINT16)(S + 0x0006)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0006))+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDU   B,U                     ; 123D: EE C5         \n");
    U = ((memory[(UINT16)(U + (SINT8)B)]<<8)|memory[(UINT16)(((UINT16)(U + (SINT8)B))+1)]);
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         LDA   $0D,X                   ; 123F: A6 0D         \n");
    A = (UINT8)memory[(UINT16)(X + 0x000d)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   $0D,U                   ; 1241: AA 4D         \n");
    A = A | memory[(UINT16)(U + 0x000d)];
    Z = A;
    N = A;
    V = 0;
                                                     mon("         BNE   $121B                   ; 1243: 26 D6         \n");
    if (Z) {
    PC = 0x121b;
    JUMP;
    }
                                                     mon("         BSR   $12AF                   ; 1245: 8D 68         \n");
    memory[--S] = 0x1247 & 0xff; memory[--S] = 0x1247 >> 8;
    PC = 0x12af;
    JUMP;
  case 0x1247:                                       mon("L1247    BCC   $121B                   ; 1247: 24 D2         \n");
    if (!C) {
    PC = 0x121b;
    JUMP;
    }
                                                     mon("         JSR   $1314                   ; 1249: BD 13 14      \n");
    memory[--S] = 0x124c & 0xff; memory[--S] = 0x124c >> 8;
    PC = 0x1314;
    JUMP;
  case 0x124C:                                       mon("L124C    BCC   $126C                   ; 124C: 24 1E         \n");
    if (!C) {
    PC = 0x126c;
    JUMP;
    }
                                                     mon("         LDA   <$B7                    ; 124E: 96 B7         \n");
    A = (UINT8)memory_DP[0xb7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$B9                    ; 1250: D6 B9         \n");
    B = (UINT8)memory_DP[0xb9];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Abs_a_b                 ; 1252: BD F5 84      \n");
    memory[--S] = 0x1255 & 0xff; memory[--S] = 0x1255 >> 8;
    PC = 0xf584;
    JUMP;
  case 0x1255:                                       mon("L1255    PSHS  B                       ; 1255: 34 04         \n");
    memory[--S] = B;
                                                     mon("         ADDA  ,S+                     ; 1257: AB E0         \n");
    res = A + memory[S];
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ memory[S] ^ (UINT8)res ^ C;
 // V = A ^ memory[S] ^ (UINT8)res ^ C;
    A = (UINT8)res;
    S = S + 1;
                                                     mon("         LSRA                          ; 1259: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 125A: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 125B: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 125C: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         CMPA  #$09                    ; 125D: 81 09         \n");
    res = A - (SINT8)0x09;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x09) & (A ^ (UINT8)res);
                                                     mon("         BLS   $1263                   ; 125F: 23 02         \n");
    if ((!Z) || C) {
    PC = 0x1263;
    JUMP;
    }
                                                     mon("         LDA   #$09                    ; 1261: 86 09         \n");
    A = (UINT8)(SINT8)0x09;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x1263:                                       mon("L1263    PSHS  A                       ; 1263: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   #$09                    ; 1265: 86 09         \n");
    A = (UINT8)(SINT8)0x09;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 1267: A0 E0         \n");
    res = A - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         JSR   $0FE1                   ; 1269: BD 0F E1      \n");
    memory[--S] = 0x126c & 0xff; memory[--S] = 0x126c >> 8;
    PC = 0x0fe1;
    JUMP;
  case 0x126C:                                       mon("L126C    LDA   $07,U                   ; 126C: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $128D                   ; 126E: 26 1D         \n");
    if (Z) {
    PC = 0x128d;
    JUMP;
    }
                                                     mon("         LDY   #$1AEC                  ; 1270: 10 8E 1A EC   \n");
    Y = 0x1aec;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDA   $07,X                   ; 1274: A6 07         \n");
    A = (UINT8)memory[(UINT16)(X + 0x0007)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$03                    ; 1276: 81 03         \n");
    res = A - (SINT8)0x03;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x03) & (A ^ (UINT8)res);
                                                     mon("         BNE   $1283                   ; 1278: 26 09         \n");
    if (Z) {
    PC = 0x1283;
    JUMP;
    }
                                                     mon("         LDA   $0B,X                   ; 127A: A6 0B         \n");
    A = (UINT8)memory[(UINT16)(X + 0x000b)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$0F                    ; 127C: 84 0F         \n");
    A = A & (SINT8)0x0f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ADDA  <$C1                    ; 127E: 9B C1         \n");
    res = A + memory_DP[0xc1];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory_DP[0xc1] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0xc1] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         DAA                           ; 1280: 19            \n");
    res = A;
    msn = res & 0xf0;
    lsn = res & 0x0f;
    res = res + (((lsn > 0x09) || (H & 0x10)) ? 0x06 : 0);
    res = res + (((msn > 0x80) && (lsn > 0x09)) || ((msn > 0x90) || (C != 0)) ? 0x60 : 0);
 // C = C | (res & 0x100);
    res = (UINT8)res;
    A = res;
 // N = res;
 // Z = res;
 // V = 0;
                                                     mon("         STA   <$C1                    ; 1281: 97 C1         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xc1] = A;
  case 0x1283:                                       mon("L1283    LDA   $07,X                   ; 1283: A6 07         \n");
    A = (UINT8)memory[(UINT16)(X + 0x0007)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ASLA                          ; 1285: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         LDD   A,Y                     ; 1286: EC A6         \n");
    val = memory[(UINT16)(Y + (SINT8)A)];
    B = memory[(UINT16)(((UINT16)(Y + (SINT8)A))+1)];
    A = val;
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12CF                   ; 1288: BD 12 CF      \n");
    memory[--S] = 0x128b & 0xff; memory[--S] = 0x128b >> 8;
    PC = 0x12cf;
    JUMP;
  case 0x128B:                                       mon("L128B    DEC   <$D4                    ; 128B: 0A D4         \n");
    res = (UINT8)(memory_DP[0xd4] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0xd4] & ~res;
    memory_DP[0xd4] = res;
  case 0x128D:                                       mon("L128D    JSR   $119F                   ; 128D: BD 11 9F      \n");
    memory[--S] = 0x1290 & 0xff; memory[--S] = 0x1290 >> 8;
    PC = 0x119f;
    JUMP;
  case 0x1290:                                       mon("L1290    LDY   #$F9DC                  ; 1290: 10 8E F9 DC   \n");
    Y = 0xf9dc;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         INC   $0D,X                   ; 1294: 6C 0D         \n");
    res = (UINT8)(memory[(UINT16)(X + 0x000d)] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory[(UINT16)(X + 0x000d)]);
    memory[(UINT16)(X + 0x000d)] = res;
                                                     mon("         LDB   $0C,X                   ; 1296: E6 0C         \n");
    B = (UINT8)memory[(UINT16)(X + 0x000c)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDB   B,Y                     ; 1298: E6 A5         \n");
    B = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         COMB                          ; 129A: 53            \n");
    B = B ^ 0xff;
 // Z = B;
 // N = B;
 // V = 0;
    C = 256;
                                                     mon("         ANDB  [$02,S]                 ; 129B: E4 F8 02      \n");
    B = B & memory[((memory[(UINT16)(S + (SINT8)0x02)]<<8)|memory[(UINT16)(S + (SINT8)0x02 + 1)])];
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   [$02,S]                 ; 129E: E7 F8 02      \n");
    Z = B;
    N = B;
    V = 0;
    memory[((memory[(UINT16)(S + (SINT8)0x02)]<<8)|memory[(UINT16)(S + (SINT8)0x02 + 1)])] = B;
                                                     mon("         JMP   $121B                   ; 12A1: 7E 12 1B      \n");
    PC = 0x121b;
    JUMP;
    
  case 0x12A4:                                       mon("L12A4    PSHS  X                       ; 12A4: 34 10         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         LDX   #$C880                  ; 12A6: 8E C8 80      \n");
    X = 0xc880;
    Z = X;
    N = (X) >> 8;
    V = 0;
                                                     mon("         BSR   $12AD                   ; 12A9: 8D 02         \n");
    memory[--S] = 0x12ab & 0xff; memory[--S] = 0x12ab >> 8;
    PC = 0x12ad;
    JUMP;
  case 0x12AB:                                       mon("L12AB    PULS  X,PC                    ; 12AB: 35 90         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x12AD:                                       mon("L12AD    STD   <$DD                    ; 12AD: DD DD         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0xdd] = A;
    memory_DP[0xdd + 1] = B;
  case 0x12AF:                                       mon("L12AF    PSHS  U,X                     ; 12AF: 34 50         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         LDA   #$03                    ; 12B1: 86 03         \n");
    A = (UINT8)(SINT8)0x03;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$9F                    ; 12B3: 97 9F         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9f] = A;
  case 0x12B5:                                       mon("L12B5    LDD   ,U++                    ; 12B5: EC C1         \n");
    A = memory[U];
    B = memory[(UINT16)((U)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
    U = U + 2;
                                                     mon("         SUBD  ,X++                    ; 12B7: A3 81         \n");
    arg = (A << 8) | B;
    res = arg - (((memory[X]<<8)|memory[(UINT16)((X)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory[X]<<8)|memory[(UINT16)((X)+1)]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
    X = X + 2;
                                                     mon("         BPL   $12BE                   ; 12B9: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x12be;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 12BB: BD 19 CB      \n");
    memory[--S] = 0x12be & 0xff; memory[--S] = 0x12be >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x12BE:                                       mon("L12BE    CMPD  <$DD                    ; 12BE: 10 93 DD      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0xdd]<<8)|memory_DP[0xdd + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0xdd]<<8)|memory_DP[0xdd + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $12CB                   ; 12C1: 2E 08         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x12cb;
    JUMP;
    }
                                                     mon("         DEC   <$9F                    ; 12C3: 0A 9F         \n");
    res = (UINT8)(memory_DP[0x9f] - 1);
    N = res;
    Z = res;
    V = memory_DP[0x9f] & ~res;
    memory_DP[0x9f] = res;
                                                     mon("         BNE   $12B5                   ; 12C5: 26 EE         \n");
    if (Z) {
    PC = 0x12b5;
    JUMP;
    }
                                                     mon("         ORCC  #$01                    ; 12C7: 1A 01         \n");
    C = 1;
                                                     mon("         PULS  X,U,PC                  ; 12C9: 35 D0         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x12CB:                                       mon("L12CB    ANDCC #$FE                    ; 12CB: 1C FE         \n");
    C = 0;
                                                     mon("         PULS  X,U,PC                  ; 12CD: 35 D0         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x12CF:                                       mon("L12CF    PSHS  U,X,B,A                 ; 12CF: 34 56         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDX   #$1AC0                  ; 12D1: 8E 1A C0      \n");
    X = 0x1ac0;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDA   <$E1                    ; 12D4: 96 E1         \n");
    A = (UINT8)memory_DP[0xe1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDX   A,X                     ; 12D6: AE 86         \n");
    X = ((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(((UINT16)(X + (SINT8)A))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LEAX  $02,X                   ; 12D8: 30 02         \n");
    X = (X + 0x0002);
 // Z = X;
                                                     mon("         PULS  A,B                     ; 12DA: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         JSR   Add_Score_d             ; 12DC: BD F8 7C      \n");
    memory[--S] = 0x12df & 0xff; memory[--S] = 0x12df >> 8;
    PC = 0xf87c;
    JUMP;
  case 0x12DF:                                       mon("L12DF    LDA   <$F2                    ; 12DF: 96 F2         \n");
    A = (UINT8)memory_DP[0xf2];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $12FF                   ; 12E1: 26 1C         \n");
    if (Z) {
    PC = 0x12ff;
    JUMP;
    }
                                                     mon("         LDD   $01,X                   ; 12E3: EC 01         \n");
    A = memory[(UINT16)(X + 0x0001)];
    B = memory[(UINT16)(((UINT16)(X + 0x0001))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CMPA  #$32                    ; 12E5: 81 32         \n");
    res = A - (SINT8)0x32;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x32) & (A ^ (UINT8)res);
                                                     mon("         BCS   $12FF                   ; 12E7: 25 16         \n");
    if (C) {
    PC = 0x12ff;
    JUMP;
    }
                                                     mon("         CMPB  #$35                    ; 12E9: C1 35         \n");
    res = B - (SINT8)0x35;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x35) & (B ^ (UINT8)res);
                                                     mon("         BCS   $12FF                   ; 12EB: 25 12         \n");
    if (C) {
    PC = 0x12ff;
    JUMP;
    }
                                                     mon("         LDX   #$1ABC                  ; 12ED: 8E 1A BC      \n");
    X = 0x1abc;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDA   <$E1                    ; 12F0: 96 E1         \n");
    A = (UINT8)memory_DP[0xe1];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         INC   [A,X]                   ; 12F2: 6C 96         \n");
    res = (UINT8)(memory[((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(X + (SINT8)A + 1)])] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory[((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(X + (SINT8)A + 1)])]);
    memory[((memory[(UINT16)(X + (SINT8)A)]<<8)|memory[(UINT16)(X + (SINT8)A + 1)])] = res;
                                                     mon("         JSR   $0AFD                   ; 12F4: BD 0A FD      \n");
    memory[--S] = 0x12f7 & 0xff; memory[--S] = 0x12f7 >> 8;
    PC = 0x0afd;
    JUMP;
  case 0x12F7:                                       mon("L12F7    LDU   #$1A23                  ; 12F7: CE 1A 23      \n");
    U = 0x1a23;
 // Z = U;
 // N = (U) >> 8;
 // V = 0;
                                                     mon("         JSR   Init_Music_x            ; 12FA: BD F6 92      \n");
    memory[--S] = 0x12fd & 0xff; memory[--S] = 0x12fd >> 8;
    PC = 0xf692;
    JUMP;
  case 0x12FD:                                       mon("L12FD    DEC   <$F2                    ; 12FD: 0A F2         \n");
    res = (UINT8)(memory_DP[0xf2] - 1);
    N = res;
    Z = res;
    V = memory_DP[0xf2] & ~res;
    memory_DP[0xf2] = res;
  case 0x12FF:                                       mon("L12FF    PULS  X,U,PC                  ; 12FF: 35 D0         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1301:                                       mon("L1301    LDD   $00,U                   ; 1301: EC 40         \n");
    A = memory[(UINT16)(U + 0x0000)];
    B = memory[(UINT16)(((UINT16)(U + 0x0000))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 1303: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   <$B7                    ; 1305: D7 B7         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xb7] = B;
                                                     mon("         LDD   $02,U                   ; 1307: EC 42         \n");
    A = memory[(UINT16)(U + 0x0002)];
    B = memory[(UINT16)(((UINT16)(U + 0x0002))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$82                    ; 1309: 93 82         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   <$B8                    ; 130B: D7 B8         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xb8] = B;
                                                     mon("         LDD   $04,U                   ; 130D: EC 44         \n");
    A = memory[(UINT16)(U + 0x0004)];
    B = memory[(UINT16)(((UINT16)(U + 0x0004))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 130F: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         STB   <$B9                    ; 1311: D7 B9         \n");
    Z = B;
    N = B;
    V = 0;
    memory_DP[0xb9] = B;
                                                     mon("         RTS                           ; 1313: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1314:                                       mon("L1314    LDD   #$60                    ; 1314: CC 00 60      \n");
    A = (UINT8)((0x0060) >> 8);
    B = (UINT8)((0x0060) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         BSR   $12A4                   ; 1317: 8D 8B         \n");
    memory[--S] = 0x1319 & 0xff; memory[--S] = 0x1319 >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x1319:                                       mon("L1319    BCC   $131F                   ; 1319: 24 04         \n");
    if (!C) {
    PC = 0x131f;
    JUMP;
    }
                                                     mon("         BSR   $1301                   ; 131B: 8D E4         \n");
    memory[--S] = 0x131d & 0xff; memory[--S] = 0x131d >> 8;
    PC = 0x1301;
    JUMP;
  case 0x131D:                                       mon("L131D    ORCC  #$01                    ; 131D: 1A 01         \n");
    C = 1;
  case 0x131F:                                       mon("L131F    RTS                           ; 131F: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1320:                                       mon("L1320    LDA   <$86                    ; 1320: 96 86         \n");
    A = (UINT8)memory_DP[0x86];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$36                    ; 1322: 97 36         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x36] = A;
                                                     mon("         JSR   Get_Rise_Run            ; 1324: BD F5 EF      \n");
    memory[--S] = 0x1327 & 0xff; memory[--S] = 0x1327 >> 8;
    PC = 0xf5ef;
    JUMP;
  case 0x1327:                                       mon("L1327    LDA   <$B7                    ; 1327: 96 B7         \n");
    A = (UINT8)memory_DP[0xb7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Rise_a            ; 1329: BD F6 61      \n");
    memory[--S] = 0x132c & 0xff; memory[--S] = 0x132c >> 8;
    PC = 0xf661;
    JUMP;
  case 0x132C:                                       mon("L132C    PSHS  A                       ; 132C: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   <$B9                    ; 132E: 96 B9         \n");
    A = (UINT8)memory_DP[0xb9];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Run_a             ; 1330: BD F6 5B      \n");
    memory[--S] = 0x1333 & 0xff; memory[--S] = 0x1333 >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x1333:                                       mon("L1333    SUBA  ,S+                     ; 1333: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         BLE   $135D                   ; 1335: 2F 26         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x135d;
    JUMP;
    }
                                                     mon("         STA   <$BA                    ; 1337: 97 BA         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xba] = A;
                                                     mon("         LDA   <$B8                    ; 1339: 96 B8         \n");
    A = (UINT8)memory_DP[0xb8];
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BSR   $1360                   ; 133B: 8D 23         \n");
    memory[--S] = 0x133d & 0xff; memory[--S] = 0x133d >> 8;
    PC = 0x1360;
    JUMP;
  case 0x133D:                                       mon("L133D    BVS   $135D                   ; 133D: 29 1E         \n");
    if ((SINT8)V <  0) {
    PC = 0x135d;
    JUMP;
    }
                                                     mon("         CMPB  #$C8                    ; 133F: C1 C8         \n");
    res = B - (SINT8)0xc8;
 // C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (B ^ (SINT8)0xc8) & (B ^ (UINT8)res);
                                                     mon("         BLE   $135D                   ; 1341: 2F 1A         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x135d;
    JUMP;
    }
                                                     mon("         STB   <$BB                    ; 1343: D7 BB         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xbb] = B;
                                                     mon("         LDA   <$B9                    ; 1345: 96 B9         \n");
    A = (UINT8)memory_DP[0xb9];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Rise_a            ; 1347: BD F6 61      \n");
    memory[--S] = 0x134a & 0xff; memory[--S] = 0x134a >> 8;
    PC = 0xf661;
    JUMP;
  case 0x134A:                                       mon("L134A    PSHS  A                       ; 134A: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   <$B7                    ; 134C: 96 B7         \n");
    A = (UINT8)memory_DP[0xb7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Run_a             ; 134E: BD F6 5B      \n");
    memory[--S] = 0x1351 & 0xff; memory[--S] = 0x1351 >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x1351:                                       mon("L1351    ADDA  ,S+                     ; 1351: AB E0         \n");
    res = A + memory[S];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory[S] ^ (UINT8)res ^ C;
 // V = A ^ memory[S] ^ (UINT8)res ^ C;
    A = (UINT8)res;
    S = S + 1;
                                                     mon("         NEGA                          ; 1353: 40            \n");
    V = (UINT8)(-A) & (A);
    C = (-A) & 0x100;
    A = (UINT8)(-A);
    Z = A;
    N = A;
                                                     mon("         BSR   $1360                   ; 1354: 8D 0A         \n");
    memory[--S] = 0x1356 & 0xff; memory[--S] = 0x1356 >> 8;
    PC = 0x1360;
    JUMP;
  case 0x1356:                                       mon("L1356    BVS   $135D                   ; 1356: 29 05         \n");
    if ((SINT8)V <  0) {
    PC = 0x135d;
    JUMP;
    }
                                                     mon("         STB   <$BC                    ; 1358: D7 BC         \n");
    Z = B;
    N = B;
 // V = 0;
    memory_DP[0xbc] = B;
                                                     mon("         ANDCC #$FD                    ; 135A: 1C FD         \n");
    V = 0;
                                                     mon("         RTS                           ; 135C: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x135D:                                       mon("L135D    ORCC  #$02                    ; 135D: 1A 02         \n");
    V = 1;
                                                     mon("         RTS                           ; 135F: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1360:                                       mon("L1360    TFR   CC,B                    ; 1360: 1F A9         \n");
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; /* Placeholder for now */
    restore_flags();
    B = CC;
                                                     mon("         BPL   $1365                   ; 1362: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1365;
    JUMP;
    }
                                                     mon("         NEGA                          ; 1364: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x1365:                                       mon("L1365    STB   <$A0                    ; 1365: D7 A0         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xa0] = B;
                                                     mon("         CMPA  <$BA                    ; 1367: 91 BA         \n");
    res = A - memory_DP[0xba];
 // C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ memory_DP[0xba]) & (A ^ (UINT8)res);
                                                     mon("         BGE   $1399                   ; 1369: 2C 2E         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x1399;
    JUMP;
    }
                                                     mon("         LDB   <$BA                    ; 136B: D6 BA         \n");
    B = (UINT8)memory_DP[0xba];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  #$02                    ; 136D: C0 02         \n");
    res = B - (SINT8)0x02;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x02) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         BCS   $1399                   ; 136F: 25 28         \n");
    if (C) {
    PC = 0x1399;
    JUMP;
    }
                                                     mon("         CMPB  #$0E                    ; 1371: C1 0E         \n");
    res = B - (SINT8)0x0e;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x0e) & (B ^ (UINT8)res);
                                                     mon("         BHI   $1377                   ; 1373: 22 02         \n");
    if (Z && (!C)) {
    PC = 0x1377;
    JUMP;
    }
                                                     mon("         DEC   <$23                    ; 1375: 0A 23         \n");
    res = (UINT8)(memory_DP[0x23] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x23] & ~res;
    memory_DP[0x23] = res;
  case 0x1377:                                       mon("L1377    LDY   #$1E41                  ; 1377: 10 8E 1E 41   \n");
    Y = 0x1e41;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDB   B,Y                     ; 137B: E6 A5         \n");
    B = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 137D: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         TST   <$23                    ; 137E: 0D 23         \n");
    Z = memory_DP[0x23];
 // N = memory_DP[0x23];
 // V = 0;
                                                     mon("         BNE   $138A                   ; 1380: 26 08         \n");
    if (Z) {
    PC = 0x138a;
    JUMP;
    }
                                                     mon("         ASRA                          ; 1382: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 1383: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 1384: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 1385: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 1386: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 1387: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 1388: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 1389: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
  case 0x138A:                                       mon("L138A    CLR   <$23                    ; 138A: 0F 23         \n");
    memory_DP[0x23] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         TSTB                          ; 138C: 5D            \n");
 // Z = B;
    N = B;
 // V = 0;
                                                     mon("         BMI   $1399                   ; 138D: 2B 0A         \n");
    if ((SINT8)N <  0) {
    PC = 0x1399;
    JUMP;
    }
                                                     mon("         LDA   <$A0                    ; 138F: 96 A0         \n");
    A = (UINT8)memory_DP[0xa0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         TFR   A,CC                    ; 1391: 1F 8A         \n");
    CC = A;
    C = CC; V = C>>1; Z = V>>1; N = Z>>1; I = N>>1; H = I>>1; F = H>>1; E = (F>>1)&1; F &= 1; H &= 1; I &= 1; N &= 1; Z &= 1; V &= 1; C &= 1;
    restore_flags();
                                                     mon("         BPL   $1396                   ; 1393: 2A 01         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1396;
    JUMP;
    }
                                                     mon("         NEGB                          ; 1395: 50            \n");
 // V = (UINT8)(-B) & (B);
    C = (-B) & 0x100;
    B = (UINT8)(-B);
    Z = B;
    N = B;
  case 0x1396:                                       mon("L1396    ANDCC #$FD                    ; 1396: 1C FD         \n");
    V = 0;
                                                     mon("         RTS                           ; 1398: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1399:                                       mon("L1399    ORCC  #$02                    ; 1399: 1A 02         \n");
    V = 1;
                                                     mon("         RTS                           ; 139B: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x139C:                                       mon("L139C    LDA   <$EC                    ; 139C: 96 EC         \n");
    A = (UINT8)memory_DP[0xec];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   <$D0                    ; 139E: 9A D0         \n");
    A = A | memory_DP[0xd0];
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BNE   $13B4                   ; 13A0: 26 12         \n");
    if (Z) {
    PC = 0x13b4;
    JUMP;
    }
                                                     mon("         LDA   <$BD                    ; 13A2: 96 BD         \n");
    A = (UINT8)memory_DP[0xbd];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BMI   $13B4                   ; 13A4: 2B 0E         \n");
    if ((SINT8)N <  0) {
    PC = 0x13b4;
    JUMP;
    }
                                                     mon("         LDA   <$C0                    ; 13A6: 96 C0         \n");
    A = (UINT8)memory_DP[0xc0];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$60                    ; 13A8: 81 60         \n");
    res = A - (SINT8)0x60;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x60) & (A ^ (UINT8)res);
                                                     mon("         BCC   $13B4                   ; 13AA: 24 08         \n");
    if (!C) {
    PC = 0x13b4;
    JUMP;
    }
                                                     mon("         LDD   #$C0                    ; 13AC: CC 00 C0      \n");
    A = (UINT8)((0x00c0) >> 8);
    B = (UINT8)((0x00c0) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $12A4                   ; 13AF: BD 12 A4      \n");
    memory[--S] = 0x13b2 & 0xff; memory[--S] = 0x13b2 >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x13B2:                                       mon("L13B2    BCS   $13B5                   ; 13B2: 25 01         \n");
    if (C) {
    PC = 0x13b5;
    JUMP;
    }
  case 0x13B4:                                       mon("L13B4    RTS                           ; 13B4: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x13B5:                                       mon("L13B5    PSHS  U,X                     ; 13B5: 34 50         \n");
    memory[--S] = U & 0xff; memory[--S] = U >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         LDD   $00,U                   ; 13B7: EC 40         \n");
    A = memory[(UINT16)(U + 0x0000)];
    B = memory[(UINT16)(((UINT16)(U + 0x0000))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 13B9: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         ASRA                          ; 13BB: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 13BC: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 13BD: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 13BE: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         STB   <$97                    ; 13BF: D7 97         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x97] = B;
                                                     mon("         LDD   $04,U                   ; 13C1: EC 44         \n");
    A = memory[(UINT16)(U + 0x0004)];
    B = memory[(UINT16)(((UINT16)(U + 0x0004))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 13C3: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         ASRA                          ; 13C5: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 13C6: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         ASRA                          ; 13C7: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 13C8: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         STB   <$98                    ; 13C9: D7 98         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x98] = B;
                                                     mon("         LDA   #$20                    ; 13CB: 86 20         \n");
    A = (UINT8)(SINT8)0x20;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  <$86                    ; 13CD: 90 86         \n");
    res = A - memory_DP[0x86];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory_DP[0x86]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         STA   <$36                    ; 13CF: 97 36         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x36] = A;
                                                     mon("         LDX   #$C897                  ; 13D1: 8E C8 97      \n");
    X = 0xc897;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LEAU  $02,X                   ; 13D4: 33 02         \n");
    U = (X + 0x0002);
                                                     mon("         JSR   Rot_VL                  ; 13D6: BD F6 16      \n");
    memory[--S] = 0x13d9 & 0xff; memory[--S] = 0x13d9 >> 8;
    PC = 0xf616;
    JUMP;
  case 0x13D9:                                       mon("L13D9    LDD   ,X                      ; 13D9: EC 84         \n");
    A = memory[X];
    B = memory[(UINT16)((X)+1)];
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $176F                   ; 13DB: BD 17 6F      \n");
    memory[--S] = 0x13de & 0xff; memory[--S] = 0x13de >> 8;
    PC = 0x176f;
    JUMP;
  case 0x13DE:                                       mon("L13DE    BVC   $13E2                   ; 13DE: 28 02         \n");
    if ((SINT8)V >= 0) {
    PC = 0x13e2;
    JUMP;
    }
                                                     mon("         PULS  X,U,PC                  ; 13E0: 35 D0         \n");    // ;(PUL? PC=RTS)
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x13E2:                                       mon("L13E2    LDB   <$26                    ; 13E2: D6 26         \n");
    B = (UINT8)memory_DP[0x26];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  <$36                    ; 13E4: D0 36         \n");
    res = B - memory_DP[0x36];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0x36]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ADDB  #$10                    ; 13E6: CB 10         \n");
    res = B + (SINT8)0x10;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = B ^ (SINT8)0x10 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         ANDB  #$3F                    ; 13E8: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         ASLB                          ; 13EA: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
    Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         PSHS  DP,B                    ; 13EB: 34 0C         \n");
    memory[--S] = (DP >> 8);
    memory[--S] = B;
                                                     mon("         BNE   $13F3                   ; 13ED: 26 04         \n");
    if (Z) {
    PC = 0x13f3;
    JUMP;
    }
                                                     mon("         LDA   #$1F                    ; 13EF: 86 1F         \n");
    A = (UINT8)(SINT8)0x1f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$D6                    ; 13F1: 97 D6         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xd6] = A;
  case 0x13F3:                                       mon("L13F3    JSR   DP_to_D0                ; 13F3: BD F1 AA      \n");
    memory[--S] = 0x13f6 & 0xff; memory[--S] = 0x13f6 >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x13F6:                                       mon("L13F6    LDA   #$7F                    ; 13F6: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 13F8: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         JSR   $0F88                   ; 13FA: BD 0F 88      \n");
    memory[--S] = 0x13fd & 0xff; memory[--S] = 0x13fd >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x13FD:                                       mon("L13FD    LDD   #$A800                  ; 13FD: CC A8 00      \n");
    A = (UINT8)((0xa800) >> 8);
    B = (UINT8)((0xa800) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 1400: BD F2 FC      \n");
    memory[--S] = 0x1403 & 0xff; memory[--S] = 0x1403 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x1403:                                       mon("L1403    LDA   #$34                    ; 1403: 86 34         \n");
    A = (UINT8)(SINT8)0x34;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 1405: 97 06         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x06] = A;
                                                     mon("         JSR   Dot_ix                  ; 1407: BD F2 C1      \n");
    memory[--S] = 0x140a & 0xff; memory[--S] = 0x140a >> 8;
    PC = 0xf2c1;
    JUMP;
  case 0x140A:                                       mon("L140A    JSR   Reset0Int               ; 140A: BD F3 6B      \n");
    memory[--S] = 0x140d & 0xff; memory[--S] = 0x140d >> 8;
    PC = 0xf36b;
    JUMP;
  case 0x140D:                                       mon("L140D    PULS  DP,X,U,PC               ; 140D: 35 D8         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    X = memory[S++]<<8;
    X |= memory[S++];
    U = memory[S++]<<8;
    U |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x140F:                                       mon("L140F    JSR   $1314                   ; 140F: BD 13 14      \n");
    memory[--S] = 0x1412 & 0xff; memory[--S] = 0x1412 >> 8;
    PC = 0x1314;
    JUMP;
  case 0x1412:                                       mon("L1412    BCC   $1419                   ; 1412: 24 05         \n");
    if (!C) {
    PC = 0x1419;
    JUMP;
    }
                                                     mon("         JSR   $1320                   ; 1414: BD 13 20      \n");
    memory[--S] = 0x1417 & 0xff; memory[--S] = 0x1417 >> 8;
    PC = 0x1320;
    JUMP;
  case 0x1417:                                       mon("L1417    BVC   $141A                   ; 1417: 28 01         \n");
    if ((SINT8)V >= 0) {
    PC = 0x141a;
    JUMP;
    }
  case 0x1419:                                       mon("L1419    RTS                           ; 1419: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x141A:                                       mon("L141A    LDA   $0D,U                   ; 141A: A6 4D         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000d)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   #$7F                    ; 141C: C6 7F         \n");
    B = (UINT8)(SINT8)0x7f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  <$BA                    ; 141E: D0 BA         \n");
    res = B - memory_DP[0xba];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0xba]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         MUL                           ; 1420: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         TFR   A,B                     ; 1421: 1F 89         \n");
    B = A;
                                                     mon("         LSRB                          ; 1423: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LDA   $0D,U                   ; 1424: A6 4D         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000d)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LSRA                          ; 1426: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         PSHS  A                       ; 1427: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   #$7F                    ; 1429: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 142B: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         PSHS  DP,B,A                  ; 142D: 34 0E         \n");
    memory[--S] = (DP >> 8);
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         JSR   DP_to_D0                ; 142F: BD F1 AA      \n");
    memory[--S] = 0x1432 & 0xff; memory[--S] = 0x1432 >> 8;
    PC = 0xf1aa;
    JUMP;
  case 0x1432:                                       mon("L1432    LDD   $C8BB                   ; 1432: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 1435: BD F2 FC      \n");
    memory[--S] = 0x1438 & 0xff; memory[--S] = 0x1438 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x1438:                                       mon("L1438    PULS  A,B                     ; 1438: 35 06         \n");
    A = memory[S++];
    B = memory[S++];
                                                     mon("         STB   <$06                    ; 143A: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
                                                     mon("         JSR   $0F88                   ; 143C: BD 0F 88      \n");
    memory[--S] = 0x143f & 0xff; memory[--S] = 0x143f >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x143F:                                       mon("L143F    LDA   #$17                    ; 143F: 86 17         \n");
    A = (UINT8)(SINT8)0x17;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   Vec_Misc_Count          ; 1441: B7 C8 23      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc823] = A;
                                                     mon("         LDX   #$1C32                  ; 1444: 8E 1C 32      \n");
    X = 0x1c32;
    Z = X;
    N = (X) >> 8;
    V = 0;
                                                     mon("         JSR   Dot_List                ; 1447: BD F2 D5      \n");
    memory[--S] = 0x144a & 0xff; memory[--S] = 0x144a >> 8;
    PC = 0xf2d5;
    JUMP;
  case 0x144A:                                       mon("L144A    PULS  DP,PC                   ; 144A: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         JSR   $139C                   ; 144C: BD 13 9C      \n");
    memory[--S] = 0x144f & 0xff; memory[--S] = 0x144f >> 8;
    PC = 0x139c;
    JUMP;
  case 0x144F:                                       mon("L144F    LDA   $0D,U                   ; 144F: A6 4D         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000d)];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BNE   $140F                   ; 1451: 26 BC         \n");
    if (Z) {
    PC = 0x140f;
    JUMP;
    }
                                                     mon("         LDD   $02,U                   ; 1453: EC 42         \n");
    A = memory[(UINT16)(U + 0x0002)];
    B = memory[(UINT16)(((UINT16)(U + 0x0002))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$82                    ; 1455: 93 82         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    V = ((arg ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         LBLE  $11D3                   ; 1457: 10 2F FD 78   \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x11d3;
    JUMP;
    }
                                                     mon("         STD   <$97                    ; 145B: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDD   $00,U                   ; 145D: EC 40         \n");
    A = memory[(UINT16)(U + 0x0000)];
    B = memory[(UINT16)(((UINT16)(U + 0x0000))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 145F: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         PSHS  B                       ; 1461: 34 04         \n");
    memory[--S] = B;
                                                     mon("         BPL   $1468                   ; 1463: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1468;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 1465: BD 19 CB      \n");
    memory[--S] = 0x1468 & 0xff; memory[--S] = 0x1468 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x1468:                                       mon("L1468    CMPD  #$60                    ; 1468: 10 83 00 60   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0060);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0060)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         PULS  B                       ; 146C: 35 04         \n");
    B = memory[S++];
                                                     mon("         BHI   $149E                   ; 146E: 22 2E         \n");
    if (Z && (!C)) {
    PC = 0x149e;
    JUMP;
    }
                                                     mon("         STB   <$B7                    ; 1470: D7 B7         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xb7] = B;
                                                     mon("         LDD   $04,U                   ; 1472: EC 44         \n");
    A = memory[(UINT16)(U + 0x0004)];
    B = memory[(UINT16)(((UINT16)(U + 0x0004))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 1474: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         PSHS  B                       ; 1476: 34 04         \n");
    memory[--S] = B;
                                                     mon("         BPL   $147D                   ; 1478: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x147d;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 147A: BD 19 CB      \n");
    memory[--S] = 0x147d & 0xff; memory[--S] = 0x147d >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x147D:                                       mon("L147D    CMPD  #$60                    ; 147D: 10 83 00 60   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x0060);
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x0060)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         PULS  B                       ; 1481: 35 04         \n");
    B = memory[S++];
                                                     mon("         BHI   $149E                   ; 1483: 22 19         \n");
    if (Z && (!C)) {
    PC = 0x149e;
    JUMP;
    }
                                                     mon("         STB   <$B9                    ; 1485: D7 B9         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xb9] = B;
                                                     mon("         LDA   <$86                    ; 1487: 96 86         \n");
    A = (UINT8)memory_DP[0x86];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$36                    ; 1489: 97 36         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x36] = A;
                                                     mon("         JSR   Get_Rise_Run            ; 148B: BD F5 EF      \n");
    memory[--S] = 0x148e & 0xff; memory[--S] = 0x148e >> 8;
    PC = 0xf5ef;
    JUMP;
  case 0x148E:                                       mon("L148E    LDA   <$B7                    ; 148E: 96 B7         \n");
    A = (UINT8)memory_DP[0xb7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Rise_a            ; 1490: BD F6 61      \n");
    memory[--S] = 0x1493 & 0xff; memory[--S] = 0x1493 >> 8;
    PC = 0xf661;
    JUMP;
  case 0x1493:                                       mon("L1493    STA   <$99                    ; 1493: 97 99         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x99] = A;
                                                     mon("         LDA   <$B9                    ; 1495: 96 B9         \n");
    A = (UINT8)memory_DP[0xb9];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Run_a             ; 1497: BD F6 5B      \n");
    memory[--S] = 0x149a & 0xff; memory[--S] = 0x149a >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x149A:                                       mon("L149A    SUBA  <$99                    ; 149A: 90 99         \n");
    res = A - memory_DP[0x99];
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ memory_DP[0x99]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BGT   $149F                   ; 149C: 2E 01         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x149f;
    JUMP;
    }
  case 0x149E:                                       mon("L149E    RTS                           ; 149E: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x149F:                                       mon("L149F    STA   <$BA                    ; 149F: 97 BA         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xba] = A;
                                                     mon("         LDA   <$B9                    ; 14A1: 96 B9         \n");
    A = (UINT8)memory_DP[0xb9];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Rise_a            ; 14A3: BD F6 61      \n");
    memory[--S] = 0x14a6 & 0xff; memory[--S] = 0x14a6 >> 8;
    PC = 0xf661;
    JUMP;
  case 0x14A6:                                       mon("L14A6    STA   <$99                    ; 14A6: 97 99         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x99] = A;
                                                     mon("         LDA   <$B7                    ; 14A8: 96 B7         \n");
    A = (UINT8)memory_DP[0xb7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   Xform_Run_a             ; 14AA: BD F6 5B      \n");
    memory[--S] = 0x14ad & 0xff; memory[--S] = 0x14ad >> 8;
    PC = 0xf65b;
    JUMP;
  case 0x14AD:                                       mon("L14AD    ADDA  <$99                    ; 14AD: 9B 99         \n");
    res = A + memory_DP[0x99];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory_DP[0x99] ^ (UINT8)res ^ C;
 // V = A ^ memory_DP[0x99] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         NEGA                          ; 14AF: 40            \n");
    V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
                                                     mon("         JSR   $1360                   ; 14B0: BD 13 60      \n");
    memory[--S] = 0x14b3 & 0xff; memory[--S] = 0x14b3 >> 8;
    PC = 0x1360;
    JUMP;
  case 0x14B3:                                       mon("L14B3    BVS   $149E                   ; 14B3: 29 E9         \n");
    if ((SINT8)V <  0) {
    PC = 0x149e;
    JUMP;
    }
                                                     mon("         STB   <$BC                    ; 14B5: D7 BC         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xbc] = B;
                                                     mon("         LDD   <$97                    ; 14B7: DC 97         \n");
    A = memory_DP[0x97];
    B = memory_DP[0x97 + 1];
 // Z = A|B;
    N = A;
 // V = 0;
                                                     mon("         BPL   $14BE                   ; 14B9: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x14be;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 14BB: BD 19 CB      \n");
    memory[--S] = 0x14be & 0xff; memory[--S] = 0x14be >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x14BE:                                       mon("L14BE    CMPD  #$7E                    ; 14BE: 10 83 00 7E   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x007e);
    C = res & 0x10000;
 // res = (UINT16)res;
 // Z = res;
 // N = res >> 8;
 // V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x007e)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BCC   $14D0                   ; 14C2: 24 0C         \n");
    if (!C) {
    PC = 0x14d0;
    JUMP;
    }
                                                     mon("         LDA   <$98                    ; 14C4: 96 98         \n");
    A = (UINT8)memory_DP[0x98];
 // N = A;
 // Z = A;
    V = 0;
                                                     mon("         JSR   $1360                   ; 14C6: BD 13 60      \n");
    memory[--S] = 0x14c9 & 0xff; memory[--S] = 0x14c9 >> 8;
    PC = 0x1360;
    JUMP;
  case 0x14C9:                                       mon("L14C9    BVS   $14D0                   ; 14C9: 29 05         \n");
    if ((SINT8)V <  0) {
    PC = 0x14d0;
    JUMP;
    }
                                                     mon("         STB   <$BB                    ; 14CB: D7 BB         \n");
    Z = B;
    N = B;
    V = 0;
    memory_DP[0xbb] = B;
                                                     mon("         JMP   $11E8                   ; 14CD: 7E 11 E8      \n");
    PC = 0x11e8;
    JUMP;
    
  case 0x14D0:                                       mon("L14D0    PSHS  DP                      ; 14D0: 34 08         \n");
    memory[--S] = (DP >> 8);
                                                     mon("         LDD   #$7AD0                  ; 14D2: CC 7A D0      \n");
    A = (UINT8)((0x7ad0) >> 8);
    B = (UINT8)((0x7ad0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$BB                    ; 14D5: 97 BB         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xbb] = A;
                                                     mon("         SUBA  <$BA                    ; 14D7: 90 BA         \n");
    res = A - memory_DP[0xba];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory_DP[0xba]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         TFR   B,DP                    ; 14D9: 1F 9B         \n");
    DP = (B) << 8;
    memory_DP = &memory[DP];
                                                     mon("         JSR   $0F88                   ; 14DB: BD 0F 88      \n");
    memory[--S] = 0x14de & 0xff; memory[--S] = 0x14de >> 8;
    PC = 0x0f88;
    JUMP;
  case 0x14DE:                                       mon("L14DE    LDD   $C8BB                   ; 14DE: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 14E1: BD F2 FC      \n");
    memory[--S] = 0x14e4 & 0xff; memory[--S] = 0x14e4 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x14E4:                                       mon("L14E4    LDA   #$FF                    ; 14E4: 86 FF         \n");
    A = (UINT8)(SINT8)0xff;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         BSR   $14FB                   ; 14E6: 8D 13         \n");
    memory[--S] = 0x14e8 & 0xff; memory[--S] = 0x14e8 >> 8;
    PC = 0x14fb;
    JUMP;
  case 0x14E8:                                       mon("L14E8    PULS  DP,PC                   ; 14E8: 35 88         \n");    // ;(PUL? PC=RTS)
    DP = memory[S++];
    DP = DP << 8;
    memory_DP = &memory[DP];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         JSR   $0B92                   ; 14EA: BD 0B 92      \n");
    memory[--S] = 0x14ed & 0xff; memory[--S] = 0x14ed >> 8;
    PC = 0x0b92;
    JUMP;
  case 0x14ED:                                       mon("L14ED    CLR   Vec_0Ref_Enable         ; 14ED: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDX   #$1C1E                  ; 14F0: 8E 1C 1E      \n");
    X = 0x1c1e;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $0B92                   ; 14F3: BD 0B 92      \n");
    memory[--S] = 0x14f6 & 0xff; memory[--S] = 0x14f6 >> 8;
    PC = 0x0b92;
    JUMP;
  case 0x14F6:                                       mon("L14F6    DEC   Vec_0Ref_Enable         ; 14F6: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         LDA   #$F0                    ; 14F9: 86 F0         \n");
    A = (UINT8)(SINT8)0xf0;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x14FB:                                       mon("L14FB    STA   <$06                    ; 14FB: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         PSHS  X                       ; 14FD: 34 10         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         LDX   #$1C22                  ; 14FF: 8E 1C 22      \n");
    X = 0x1c22;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         LDB   #$0E                    ; 1502: C6 0E         \n");
    B = (UINT8)(SINT8)0x0e;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   $C8B4                   ; 1504: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         MUL                           ; 1507: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 1508: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         PSHS  A                       ; 150A: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDD   $C8BB                   ; 150C: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 150F: A0 E0         \n");
    res = A - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         ADDA  #$80                    ; 1511: 8B 80         \n");
    res = A + (SINT8)0x80;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x80 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x80 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         ADDB  #$80                    ; 1513: CB 80         \n");
    res = B + (SINT8)0x80;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = B ^ (SINT8)0x80 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x80 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         LSRB                          ; 1515: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1516: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1517: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1518: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         SUBA  B,X                     ; 1519: A0 85         \n");
    res = A - memory[(UINT16)(X + (SINT8)B)];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[(UINT16)(X + (SINT8)B)]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         PULS  X                       ; 151B: 35 10         \n");
    X = memory[S++]<<8;
    X |= memory[S++];
                                                     mon("         SUBA  #$27                    ; 151D: 80 27         \n");
    res = A - (SINT8)0x27;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x27) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         LSRA                          ; 151F: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         NEGA                          ; 1520: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
                                                     mon("         CLRB                          ; 1521: 5F            \n");
    B = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         JMP   Draw_Line_d             ; 1522: 7E F3 DF      \n");
    PC = 0xf3df;
    JUMP;
    
  case 0x1525:                                       mon("L1525    PSHS  X,B,A                   ; 1525: 34 16         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDA   #$03                    ; 1527: 86 03         \n");
    A = (UINT8)(SINT8)0x03;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $C89F                   ; 1529: B7 C8 9F      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc89f] = A;
  case 0x152C:                                       mon("L152C    CLRA                          ; 152C: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 152D: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         STD   $C8A1                   ; 152E: FD C8 A1      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc8a1] = A;
    memory[0xc8a1 + 1] = B;
                                                     mon("         LDA   #$CE                    ; 1531: 86 CE         \n");
    A = (UINT8)(SINT8)0xce;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0C                    ; 1533: 97 0C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0c] = A;
                                                     mon("         LDA   $C89F                   ; 1535: B6 C8 9F      \n");
    A = (UINT8)memory[0xc89f];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LSRA                          ; 1538: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         ROL   $C8A1                   ; 1539: 79 C8 A1      \n");
    res = ((memory[0xc8a1]) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (memory[0xc8a1]);
    memory[0xc8a1] = (UINT8)res;
                                                     mon("         LSRA                          ; 153C: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         ROL   $C8A2                   ; 153D: 79 C8 A2      \n");
    res = ((memory[0xc8a2]) << 1) + (C != 0 ?1:0);
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (memory[0xc8a2]);
    memory[0xc8a2] = (UINT8)res;
                                                     mon("         LDX   $02,S                   ; 1540: AE 62         \n");
    X = ((memory[(UINT16)(S + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0002))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $16BE                   ; 1542: BD 16 BE      \n");
    memory[--S] = 0x1545 & 0xff; memory[--S] = 0x1545 >> 8;
    PC = 0x16be;
    JUMP;
  case 0x1545:                                       mon("L1545    DEC   $C89F                   ; 1545: 7A C8 9F      \n");
    res = (UINT8)(memory[0xc89f] - 1);
    N = res;
    Z = res;
    V = memory[0xc89f] & ~res;
    memory[0xc89f] = res;
                                                     mon("         BPL   $152C                   ; 1548: 2A E2         \n");
    if ((SINT8)N >= 0) {
    PC = 0x152c;
    JUMP;
    }
                                                     mon("         PULS  A,B,X,PC                ; 154A: 35 96         \n");    // ;(PUL? PC=RTS)
    A = memory[S++];
    B = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         LDA   $C8C7                   ; 154C: B6 C8 C7      \n");
    A = (UINT8)memory[0xc8c7];
 // N = A;
    Z = A;
 // V = 0;
                                                     mon("         BEQ   $1556                   ; 154F: 27 05         \n");
    if (!Z) {
    PC = 0x1556;
    JUMP;
    }
                                                     mon("         LDA   $C8C8                   ; 1551: B6 C8 C8      \n");
    A = (UINT8)memory[0xc8c8];
    N = A;
 // Z = A;
    V = 0;
                                                     mon("         BGE   $156F                   ; 1554: 2C 19         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x156f;
    JUMP;
    }
  case 0x1556:                                       mon("L1556    PSHS  X                       ; 1556: 34 10         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         JSR   $0B92                   ; 1558: BD 0B 92      \n");
    memory[--S] = 0x155b & 0xff; memory[--S] = 0x155b >> 8;
    PC = 0x0b92;
    JUMP;
  case 0x155B:                                       mon("L155B    PULS  X                       ; 155B: 35 10         \n");
    X = memory[S++]<<8;
    X |= memory[S++];
                                                     mon("         LDA   $C8B4                   ; 155D: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LSRA                          ; 1560: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 1561: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         PSHS  A                       ; 1562: 34 02         \n");
    memory[--S] = A;
                                                     mon("         LDA   $C8B4                   ; 1564: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 1567: A0 E0         \n");
    res = A - memory[S];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         STA   $C8B4                   ; 1569: B7 C8 B4      \n");
    Z = A;
    N = A;
    V = 0;
    memory[0xc8b4] = A;
                                                     mon("         JMP   $0BA1                   ; 156C: 7E 0B A1      \n");
    PC = 0x0ba1;
    JUMP;
    
  case 0x156F:                                       mon("L156F    PSHS  X                       ; 156F: 34 10         \n");
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
                                                     mon("         LDD   #$CE7F                  ; 1571: CC CE 7F      \n");
    A = (UINT8)((0xce7f) >> 8);
    B = (UINT8)((0xce7f) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$0C                    ; 1574: 97 0C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0c] = A;
                                                     mon("         SUBB  $C8BA                   ; 1576: F0 C8 BA      \n");
    res = B - memory[0xc8ba];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[0xc8ba]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         JSR   $16BC                   ; 1579: BD 16 BC      \n");
    memory[--S] = 0x157c & 0xff; memory[--S] = 0x157c >> 8;
    PC = 0x16bc;
    JUMP;
  case 0x157C:                                       mon("L157C    LDA   #$CE                    ; 157C: 86 CE         \n");
    A = (UINT8)(SINT8)0xce;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$0C                    ; 157E: 97 0C         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0c] = A;
                                                     mon("         LDA   <$06                    ; 1580: 96 06         \n");
    A = (UINT8)memory_DP[0x06];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$06                    ; 1582: D6 06         \n");
    B = (UINT8)memory_DP[0x06];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LSRA                          ; 1584: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 1585: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         STA   <$06                    ; 1586: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         SUBB  <$06                    ; 1588: D0 06         \n");
    res = B - memory_DP[0x06];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0x06]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         STB   <$06                    ; 158A: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
                                                     mon("         PULS  X                       ; 158C: 35 10         \n");
    X = memory[S++]<<8;
    X |= memory[S++];
                                                     mon("         JSR   $16BC                   ; 158E: BD 16 BC      \n");
    memory[--S] = 0x1591 & 0xff; memory[--S] = 0x1591 >> 8;
    PC = 0x16bc;
    JUMP;
  case 0x1591:                                       mon("L1591    LDB   $C8C7                   ; 1591: F6 C8 C7      \n");
    B = (UINT8)memory[0xc8c7];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LSRB                          ; 1594: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1595: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1596: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 1597: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         CMPB  #$07                    ; 1598: C1 07         \n");
    res = B - (SINT8)0x07;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x07) & (B ^ (UINT8)res);
                                                     mon("         BLS   $159E                   ; 159A: 23 02         \n");
    if ((!Z) || C) {
    PC = 0x159e;
    JUMP;
    }
                                                     mon("         LDB   #$07                    ; 159C: C6 07         \n");
    B = (UINT8)(SINT8)0x07;
 // N = B;
 // Z = B;
 // V = 0;
  case 0x159E:                                       mon("L159E    LDX   #$1BAF                  ; 159E: 8E 1B AF      \n");
    X = 0x1baf;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         TSTB                          ; 15A1: 5D            \n");
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BEQ   $15A7                   ; 15A2: 27 03         \n");
    if (!Z) {
    PC = 0x15a7;
    JUMP;
    }
                                                     mon("         JSR   $1525                   ; 15A4: BD 15 25      \n");
    memory[--S] = 0x15a7 & 0xff; memory[--S] = 0x15a7 >> 8;
    PC = 0x1525;
    JUMP;
  case 0x15A7:                                       mon("L15A7    LEAX  $08,X                   ; 15A7: 30 08         \n");
    X = (X + 0x0008);
 // Z = X;
                                                     mon("         CMPB  #$02                    ; 15A9: C1 02         \n");
    res = B - (SINT8)0x02;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x02) & (B ^ (UINT8)res);
                                                     mon("         BCC   $15B1                   ; 15AB: 24 04         \n");
    if (!C) {
    PC = 0x15b1;
    JUMP;
    }
                                                     mon("         ASLB                          ; 15AD: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         ASLB                          ; 15AE: 58            \n");
    res = B << 1;
    C = res & 0x100;
    res = (UINT8)res;
    Z = res;
    N = res;
    V = B ^ res;
    B = res;
                                                     mon("         BRA   $15B8                   ; 15AF: 20 07         \n");
    PC = 0x15b8;
    JUMP;
    
  case 0x15B1:                                       mon("L15B1    LEAX  $0A,X                   ; 15B1: 30 0A         \n");
    X = (X + 0x000a);
 // Z = X;
                                                     mon("         LDA   #$0A                    ; 15B3: 86 0A         \n");
    A = (UINT8)(SINT8)0x0a;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBB  #$02                    ; 15B5: C0 02         \n");
    res = B - (SINT8)0x02;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ (SINT8)0x02) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         MUL                           ; 15B7: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
 // C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
  case 0x15B8:                                       mon("L15B8    ABX                           ; 15B8: 3A            \n");
    X = X + B;
                                                     mon("         JSR   $1525                   ; 15B9: BD 15 25      \n");
    memory[--S] = 0x15bc & 0xff; memory[--S] = 0x15bc >> 8;
    PC = 0x1525;
    JUMP;
  case 0x15BC:                                       mon("L15BC    LDA   $C8C7                   ; 15BC: B6 C8 C7      \n");
    A = (UINT8)memory[0xc8c7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  #$40                    ; 15BF: 80 40         \n");
    res = A - (SINT8)0x40;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ (SINT8)0x40) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BCC   $15C4                   ; 15C1: 24 01         \n");
    if (!C) {
    PC = 0x15c4;
    JUMP;
    }
                                                     mon("         RTS                           ; 15C3: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x15C4:                                       mon("L15C4    CMPA  #$7F                    ; 15C4: 81 7F         \n");
    res = A - (SINT8)0x7f;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x7f) & (A ^ (UINT8)res);
                                                     mon("         BLS   $15CA                   ; 15C6: 23 02         \n");
    if ((!Z) || C) {
    PC = 0x15ca;
    JUMP;
    }
                                                     mon("         LDA   #$7F                    ; 15C8: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x15CA:                                       mon("L15CA    STA   $C8B4                   ; 15CA: B7 C8 B4      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b4] = A;
                                                     mon("         LDD   #$C4E0                  ; 15CD: CC C4 E0      \n");
    A = (UINT8)((0xc4e0) >> 8);
    B = (UINT8)((0xc4e0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 15D0: BD F2 FC      \n");
    memory[--S] = 0x15d3 & 0xff; memory[--S] = 0x15d3 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x15D3:                                       mon("L15D3    LDA   $C8B4                   ; 15D3: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 15D6: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDD   #$3A1A                  ; 15D8: CC 3A 1A      \n");
    A = (UINT8)((0x3a1a) >> 8);
    B = (UINT8)((0x3a1a) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Draw_Line_d             ; 15DB: BD F3 DF      \n");
    memory[--S] = 0x15de & 0xff; memory[--S] = 0x15de >> 8;
    PC = 0xf3df;
    JUMP;
  case 0x15DE:                                       mon("L15DE    LDD   #$C420                  ; 15DE: CC C4 20      \n");
    A = (UINT8)((0xc420) >> 8);
    B = (UINT8)((0xc420) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 15E1: BD F2 FC      \n");
    memory[--S] = 0x15e4 & 0xff; memory[--S] = 0x15e4 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x15E4:                                       mon("L15E4    LDA   $C8B4                   ; 15E4: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$06                    ; 15E7: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDD   #$3AE6                  ; 15E9: CC 3A E6      \n");
    A = (UINT8)((0x3ae6) >> 8);
    B = (UINT8)((0x3ae6) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CLR   Vec_0Ref_Enable         ; 15EC: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         JSR   Draw_Line_d             ; 15EF: BD F3 DF      \n");
    memory[--S] = 0x15f2 & 0xff; memory[--S] = 0x15f2 >> 8;
    PC = 0xf3df;
    JUMP;
  case 0x15F2:                                       mon("L15F2    DEC   Vec_0Ref_Enable         ; 15F2: 7A C8 24      \n");
    res = (UINT8)(memory[0xc824] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc824] & ~res;
    memory[0xc824] = res;
                                                     mon("         LDA   #$A0                    ; 15F5: 86 A0         \n");
    A = (UINT8)(SINT8)0xa0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8B4                   ; 15F7: B0 C8 B4      \n");
    res = A - memory[0xc8b4];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[0xc8b4]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         STA   <$06                    ; 15FA: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDD   #$CE                    ; 15FC: CC 00 CE      \n");
    A = (UINT8)((0x00ce) >> 8);
    B = (UINT8)((0x00ce) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Draw_Line_d             ; 15FF: BD F3 DF      \n");
    memory[--S] = 0x1602 & 0xff; memory[--S] = 0x1602 >> 8;
    PC = 0xf3df;
    JUMP;
  case 0x1602:                                       mon("L1602    LDD   #$C600                  ; 1602: CC C6 00      \n");
    A = (UINT8)((0xc600) >> 8);
    B = (UINT8)((0xc600) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 1605: BD F2 FC      \n");
    memory[--S] = 0x1608 & 0xff; memory[--S] = 0x1608 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x1608:                                       mon("L1608    LDA   $C8B4                   ; 1608: B6 C8 B4      \n");
    A = (UINT8)memory[0xc8b4];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  #$08                    ; 160B: 80 08         \n");
    res = A - (SINT8)0x08;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x08) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BCC   $1610                   ; 160D: 24 01         \n");
    if (!C) {
    PC = 0x1610;
    JUMP;
    }
                                                     mon("         CLRA                          ; 160F: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x1610:                                       mon("L1610    STA   <$06                    ; 1610: 97 06         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x06] = A;
                                                     mon("         LDA   #$CC                    ; 1612: 86 CC         \n");
    A = (UINT8)(SINT8)0xcc;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   Vec_Pattern             ; 1614: B7 C8 29      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc829] = A;
                                                     mon("         LDD   #$3A00                  ; 1617: CC 3A 00      \n");
    A = (UINT8)((0x3a00) >> 8);
    B = (UINT8)((0x3a00) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Draw_Pat_VL_d           ; 161A: BD F4 39      \n");
    memory[--S] = 0x161d & 0xff; memory[--S] = 0x161d >> 8;
    PC = 0xf439;
    JUMP;
  case 0x161D:                                       mon("L161D    JSR   Reset0Ref               ; 161D: BD F3 54      \n");
    memory[--S] = 0x1620 & 0xff; memory[--S] = 0x1620 >> 8;
    PC = 0xf354;
    JUMP;
  case 0x1620:                                       mon("L1620    LDA   $C8C7                   ; 1620: B6 C8 C7      \n");
    A = (UINT8)memory[0xc8c7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$E0                    ; 1623: 81 E0         \n");
    res = A - (SINT8)0xe0;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0xe0) & (A ^ (UINT8)res);
                                                     mon("         BCC   $1628                   ; 1625: 24 01         \n");
    if (!C) {
    PC = 0x1628;
    JUMP;
    }
                                                     mon("         RTS                           ; 1627: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1628:                                       mon("L1628    LDB   $C8C8                   ; 1628: F6 C8 C8      \n");
    B = (UINT8)memory[0xc8c8];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BNE   $1634                   ; 162B: 26 07         \n");
    if (Z) {
    PC = 0x1634;
    JUMP;
    }
                                                     mon("         LDA   #$E0                    ; 162D: 86 E0         \n");
    A = (UINT8)(SINT8)0xe0;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8C7                   ; 162F: B0 C8 C7      \n");
    res = A - memory[0xc8c7];
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = ((A) ^ memory[0xc8c7]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         BRA   $1636                   ; 1632: 20 02         \n");
    PC = 0x1636;
    JUMP;
    
  case 0x1634:                                       mon("L1634    ADDA  #$E1                    ; 1634: 8B E1         \n");
    res = A + (SINT8)0xe1;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0xe1 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0xe1 ^ (UINT8)res ^ C;
    A = (UINT8)res;
  case 0x1636:                                       mon("L1636    CLRB                          ; 1636: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         STD   $C8BB                   ; 1637: FD C8 BB      \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[0xc8bb] = A;
    memory[0xc8bb + 1] = B;
                                                     mon("         NEGA                          ; 163A: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
                                                     mon("         ASLA                          ; 163B: 48            \n");
    res = A << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = A ^ res;
    A = res;
                                                     mon("         STA   $C8B4                   ; 163C: B7 C8 B4      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b4] = A;
                                                     mon("         LDX   #$1B93                  ; 163F: 8E 1B 93      \n");
    X = 0x1b93;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $0BA1                   ; 1642: BD 0B A1      \n");
    memory[--S] = 0x1645 & 0xff; memory[--S] = 0x1645 >> 8;
    PC = 0x0ba1;
    JUMP;
  case 0x1645:                                       mon("L1645    JSR   $0BA1                   ; 1645: BD 0B A1      \n");
    memory[--S] = 0x1648 & 0xff; memory[--S] = 0x1648 >> 8;
    PC = 0x0ba1;
    JUMP;
  case 0x1648:                                       mon("L1648    DEC   $C8A2                   ; 1648: 7A C8 A2      \n");
    res = (UINT8)(memory[0xc8a2] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc8a2] & ~res;
    memory[0xc8a2] = res;
                                                     mon("         LDX   #$1B93                  ; 164B: 8E 1B 93      \n");
    X = 0x1b93;
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $0BA1                   ; 164E: BD 0B A1      \n");
    memory[--S] = 0x1651 & 0xff; memory[--S] = 0x1651 >> 8;
    PC = 0x0ba1;
    JUMP;
  case 0x1651:                                       mon("L1651    JSR   $0BA1                   ; 1651: BD 0B A1      \n");
    memory[--S] = 0x1654 & 0xff; memory[--S] = 0x1654 >> 8;
    PC = 0x0ba1;
    JUMP;
  case 0x1654:                                       mon("L1654    CLR   $C8A2                   ; 1654: 7F C8 A2      \n");
    memory[0xc8a2] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         RTS                           ; 1657: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         LDD   $C8BB                   ; 1658: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 165B: BD F2 FC      \n");
    memory[--S] = 0x165e & 0xff; memory[--S] = 0x165e >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x165E:                                       mon("L165E    LDA   #$7F                    ; 165E: 86 7F         \n");
    A = (UINT8)(SINT8)0x7f;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $C8BA                   ; 1660: B0 C8 BA      \n");
    res = A - memory[0xc8ba];
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[0xc8ba]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         STA   <$06                    ; 1663: 97 06         \n");
    Z = A;
    N = A;
    V = 0;
    memory_DP[0x06] = A;
                                                     mon("         JSR   Intensity_a             ; 1665: BD F2 AB      \n");
    memory[--S] = 0x1668 & 0xff; memory[--S] = 0x1668 >> 8;
    PC = 0xf2ab;
    JUMP;
  case 0x1668:                                       mon("L1668    JMP   Draw_VLc                ; 1668: 7E F3 CE      \n");
    PC = 0xf3ce;
    JUMP;
    
                                                     mon("         LDA   $C8B7                   ; 166B: B6 C8 B7      \n");
    A = (UINT8)memory[0xc8b7];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $C8B9                   ; 166E: F6 C8 B9      \n");
    B = (UINT8)memory[0xc8b9];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Rise_Run_Angle          ; 1671: BD F5 93      \n");
    memory[--S] = 0x1674 & 0xff; memory[--S] = 0x1674 >> 8;
    PC = 0xf593;
    JUMP;
  case 0x1674:                                       mon("L1674    LDB   Vec_Angle               ; 1674: F6 C8 36      \n");
    B = (UINT8)memory[0xc836];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  $06,U                   ; 1677: E0 46         \n");
    res = B - memory[(UINT16)(U + 0x0006)];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[(UINT16)(U + 0x0006)]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ANDB  #$3F                    ; 1679: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         LSRB                          ; 167B: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 167C: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         CMPB  #$08                    ; 167D: C1 08         \n");
    res = B - (SINT8)0x08;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x08) & (B ^ (UINT8)res);
                                                     mon("         BLS   $168A                   ; 167F: 23 09         \n");
    if ((!Z) || C) {
    PC = 0x168a;
    JUMP;
    }
                                                     mon("         PSHS  B                       ; 1681: 34 04         \n");
    memory[--S] = B;
                                                     mon("         LDB   #$10                    ; 1683: C6 10         \n");
    B = (UINT8)(SINT8)0x10;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  ,S+                     ; 1685: E0 E0         \n");
    res = B - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[S]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
    S = S + 1;
                                                     mon("         DEC   $C8A2                   ; 1687: 7A C8 A2      \n");
    res = (UINT8)(memory[0xc8a2] - 1);
 // N = res;
 // Z = res;
 // V = memory[0xc8a2] & ~res;
    memory[0xc8a2] = res;
  case 0x168A:                                       mon("L168A    ASLB                          ; 168A: 58            \n");
    res = B << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = B ^ res;
    B = res;
                                                     mon("         LDX   B,X                     ; 168B: AE 85         \n");
    X = ((memory[(UINT16)(X + (SINT8)B)]<<8)|memory[(UINT16)(((UINT16)(X + (SINT8)B))+1)]);
 // Z = X;
 // N = (X) >> 8;
 // V = 0;
                                                     mon("         JSR   $0B92                   ; 168D: BD 0B 92      \n");
    memory[--S] = 0x1690 & 0xff; memory[--S] = 0x1690 >> 8;
    PC = 0x0b92;
    JUMP;
  case 0x1690:                                       mon("L1690    CLR   $C8A2                   ; 1690: 7F C8 A2      \n");
    memory[0xc8a2] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         RTS                           ; 1693: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         LDA   $0B,U                   ; 1694: A6 4B         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   #$12                    ; 1696: C6 12         \n");
    B = (UINT8)(SINT8)0x12;
    N = B;
 // Z = B;
    V = 0;
                                                     mon("         MUL                           ; 1698: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         LEAX  B,X                     ; 1699: 30 85         \n");
    X = (X + (SINT8)B);
    Z = X;
                                                     mon("         JMP   $0B92                   ; 169B: 7E 0B 92      \n");
    PC = 0x0b92;
    JUMP;
    
                                                     mon("         LDD   $C8BB                   ; 169E: FC C8 BB      \n");
    A = memory[0xc8bb];
    B = memory[(UINT16)((0xc8bb)+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   Moveto_d_7F             ; 16A1: BD F2 FC      \n");
    memory[--S] = 0x16a4 & 0xff; memory[--S] = 0x16a4 >> 8;
    PC = 0xf2fc;
    JUMP;
  case 0x16A4:                                       mon("L16A4    LDB   #$7F                    ; 16A4: C6 7F         \n");
    B = (UINT8)(SINT8)0x7f;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  $C8BA                   ; 16A6: F0 C8 BA      \n");
    res = B - memory[0xc8ba];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[0xc8ba]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         LSRB                          ; 16A9: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LDA   $06,U                   ; 16AA: A6 46         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0006)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LSRA                          ; 16AC: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         ROL   $C8A2                   ; 16AD: 79 C8 A2      \n");
    res = ((memory[0xc8a2]) << 1) + (C != 0 ?1:0);
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = res;
 // V = res ^ (memory[0xc8a2]);
    memory[0xc8a2] = (UINT8)res;
                                                     mon("         LSRA                          ; 16B0: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         ROL   $C8A1                   ; 16B1: 79 C8 A1      \n");
    res = ((memory[0xc8a1]) << 1) + (C != 0 ?1:0);
    C = res & 0x100;
    Z = (UINT8)res;
    N = res;
    V = res ^ (memory[0xc8a1]);
    memory[0xc8a1] = (UINT8)res;
                                                     mon("         BSR   $16BC                   ; 16B4: 8D 06         \n");
    memory[--S] = 0x16b6 & 0xff; memory[--S] = 0x16b6 >> 8;
    PC = 0x16bc;
    JUMP;
  case 0x16B6:                                       mon("L16B6    CLRA                          ; 16B6: 4F            \n");
    A = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         CLRB                          ; 16B7: 5F            \n");
    B = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         STD   $C8A1                   ; 16B8: FD C8 A1      \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[0xc8a1] = A;
    memory[0xc8a1 + 1] = B;
                                                     mon("         RTS                           ; 16BB: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x16BC:                                       mon("L16BC    STB   <$06                    ; 16BC: D7 06         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0x06] = B;
  case 0x16BE:                                       mon("L16BE    LDA   ,X+                     ; 16BE: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         STA   Vec_Misc_Count          ; 16C0: B7 C8 23      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc823] = A;
                                                     mon("         CLR   $C8B5                   ; 16C3: 7F C8 B5      \n");
    memory[0xc8b5] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
  case 0x16C6:                                       mon("L16C6    DEC   Vec_Misc_Count          ; 16C6: 7A C8 23      \n");
    res = (UINT8)(memory[0xc823] - 1);
    N = res;
 // Z = res;
 // V = memory[0xc823] & ~res;
    memory[0xc823] = res;
                                                     mon("         BPL   $16D7                   ; 16C9: 2A 0C         \n");
    if ((SINT8)N >= 0) {
    PC = 0x16d7;
    JUMP;
    }
                                                     mon("         CLR   Vec_Misc_Count          ; 16CB: 7F C8 23      \n");
    memory[0xc823] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         LDA   #$40                    ; 16CE: 86 40         \n");
    A = (UINT8)(SINT8)0x40;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x16D0:                                       mon("L16D0    BITA  <$0D                    ; 16D0: 95 0D         \n");
    res = A & memory_DP[0x0d];
    Z = res;
    N = res;
    V = 0;
                                                     mon("         BEQ   $16D0                   ; 16D2: 27 FC         \n");
    if (!Z) {
    PC = 0x16d0;
    JUMP;
    }
                                                     mon("         JMP   Check0Ref               ; 16D4: 7E F3 4F      \n");
    PC = 0xf34f;
    JUMP;
    
  case 0x16D7:                                       mon("L16D7    ASL   $C8B6                   ; 16D7: 78 C8 B6      \n");
    res = memory[0xc8b6] << 1;
 // C = res & 0x100;
    res = (UINT8)res;
 // Z = res;
 // N = res;
 // V = memory[0xc8b6] ^ res;
    memory[0xc8b6] = res;
                                                     mon("         DEC   $C8B5                   ; 16DA: 7A C8 B5      \n");
    res = (UINT8)(memory[0xc8b5] - 1);
    N = res;
 // Z = res;
 // V = memory[0xc8b5] & ~res;
    memory[0xc8b5] = res;
                                                     mon("         BPL   $16E9                   ; 16DD: 2A 0A         \n");
    if ((SINT8)N >= 0) {
    PC = 0x16e9;
    JUMP;
    }
                                                     mon("         LDA   #$07                    ; 16DF: 86 07         \n");
    A = (UINT8)(SINT8)0x07;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $C8B5                   ; 16E1: B7 C8 B5      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b5] = A;
                                                     mon("         LDA   ,X+                     ; 16E4: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         STA   $C8B6                   ; 16E6: B7 C8 B6      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b6] = A;
  case 0x16E9:                                       mon("L16E9    LDA   ,X+                     ; 16E9: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         TST   $C8A1                   ; 16EB: 7D C8 A1      \n");
    Z = memory[0xc8a1];
 // N = memory[0xc8a1];
 // V = 0;
                                                     mon("         BEQ   $16F1                   ; 16EE: 27 01         \n");
    if (!Z) {
    PC = 0x16f1;
    JUMP;
    }
                                                     mon("         NEGA                          ; 16F0: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x16F1:                                       mon("L16F1    STA   <$01                    ; 16F1: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         CLR   <$00                    ; 16F3: 0F 00         \n");
    memory_DP[0x00] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDB   $C8B6                   ; 16F5: F6 C8 B6      \n");
    B = (UINT8)memory[0xc8b6];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   ,X+                     ; 16F8: A6 80         \n");
    A = (UINT8)memory[X];
 // N = A;
 // Z = A;
 // V = 0;
    X = X + 1;
                                                     mon("         INC   <$00                    ; 16FA: 0C 00         \n");
    res = (UINT8)(memory_DP[0x00] + 1);
 // Z = res;
 // N = res;
 // V = res & ~(memory_DP[0x00]);
    memory_DP[0x00] = res;
                                                     mon("         TST   $C8A2                   ; 16FC: 7D C8 A2      \n");
    Z = memory[0xc8a2];
 // N = memory[0xc8a2];
 // V = 0;
                                                     mon("         BEQ   $1702                   ; 16FF: 27 01         \n");
    if (!Z) {
    PC = 0x1702;
    JUMP;
    }
                                                     mon("         NEGA                          ; 1701: 40            \n");
 // V = (UINT8)(-A) & (A);
 // C = (-A) & 0x100;
    A = (UINT8)(-A);
 // Z = A;
 // N = A;
  case 0x1702:                                       mon("L1702    STA   <$01                    ; 1702: 97 01         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x01] = A;
                                                     mon("         SEX                           ; 1704: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         STA   <$0A                    ; 1705: 97 0A         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x0a] = A;
                                                     mon("         CLR   <$05                    ; 1707: 0F 05         \n");
    memory_DP[0x05] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDA   #$40                    ; 1709: 86 40         \n");
    A = (UINT8)(SINT8)0x40;
 // N = A;
 // Z = A;
 // V = 0;
  case 0x170B:                                       mon("L170B    BITA  <$0D                    ; 170B: 95 0D         \n");
    res = A & memory_DP[0x0d];
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $170B                   ; 170D: 27 FC         \n");
    if (!Z) {
    PC = 0x170b;
    JUMP;
    }
                                                     mon("         NOP                           ; 170F: 12            \n");
                                                     mon("         CLR   <$0A                    ; 1710: 0F 0A         \n");
    memory_DP[0x0a] = 0;
    V = 0;
    Z = 0;
    N = 0;
    C = 0;
                                                     mon("         BRA   $16C6                   ; 1712: 20 B2         \n");
    PC = 0x16c6;
    JUMP;
    
  case 0x1714:                                       mon("L1714    LDA   Vec_0Ref_Enable         ; 1714: B6 C8 24      \n");
    A = (UINT8)memory[0xc824];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         PSHS  Y,X,A                   ; 1717: 34 32         \n");
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
    memory[--S] = X & 0xff; memory[--S] = X >> 8;
    memory[--S] = A;
                                                     mon("         CLR   Vec_0Ref_Enable         ; 1719: 7F C8 24      \n");
    memory[0xc824] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
 // C = 0;
                                                     mon("         LDY   #$1FB9                  ; 171C: 10 8E 1F B9   \n");
    Y = 0x1fb9;
 // Z = Y;
 // N = (Y) >> 8;
 // V = 0;
                                                     mon("         LDA   #$01                    ; 1720: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $C89E                   ; 1722: B7 C8 9E      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc89e] = A;
  case 0x1725:                                       mon("L1725    LDA   #$07                    ; 1725: 86 07         \n");
    A = (UINT8)(SINT8)0x07;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   Vec_Misc_Count          ; 1727: B7 C8 23      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc823] = A;
                                                     mon("         STA   $C8B5                   ; 172A: B7 C8 B5      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b5] = A;
                                                     mon("         LDA   ,U                      ; 172D: A6 C4         \n");
    A = (UINT8)memory[U];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $C89E                   ; 172F: F6 C8 9E      \n");
    B = (UINT8)memory[0xc89e];
 // N = B;
    Z = B;
 // V = 0;
                                                     mon("         BEQ   $1738                   ; 1732: 27 04         \n");
    if (!Z) {
    PC = 0x1738;
    JUMP;
    }
                                                     mon("         LSRA                          ; 1734: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 1735: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 1736: 44            \n");
 // C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
                                                     mon("         LSRA                          ; 1737: 44            \n");
    C = (A) & 1;
    A = (A) >> 1;
 // N = 0;
 // Z = A;
  case 0x1738:                                       mon("L1738    ANDA  #$0F                    ; 1738: 84 0F         \n");
    A = A & (SINT8)0x0f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         LDA   A,Y                     ; 173A: A6 A6         \n");
    A = (UINT8)memory[(UINT16)(Y + (SINT8)A)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   $C8B6                   ; 173C: B7 C8 B6      \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[0xc8b6] = A;
                                                     mon("         LDX   #$1FC3                  ; 173F: 8E 1F C3      \n");
    X = 0x1fc3;
    Z = X;
    N = (X) >> 8;
    V = 0;
                                                     mon("         BSR   $16E9                   ; 1742: 8D A5         \n");
    memory[--S] = 0x1744 & 0xff; memory[--S] = 0x1744 >> 8;
    PC = 0x16e9;
    JUMP;
  case 0x1744:                                       mon("L1744    DEC   $C89E                   ; 1744: 7A C8 9E      \n");
    res = (UINT8)(memory[0xc89e] - 1);
    N = res;
 // Z = res;
 // V = memory[0xc89e] & ~res;
    memory[0xc89e] = res;
                                                     mon("         BPL   $1725                   ; 1747: 2A DC         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1725;
    JUMP;
    }
                                                     mon("         PULS  A,X,Y                   ; 1749: 35 32         \n");
    A = memory[S++];
    X = memory[S++]<<8;
    X |= memory[S++];
    Y = memory[S++]<<8;
    Y |= memory[S++];
                                                     mon("         STA   Vec_0Ref_Enable         ; 174B: B7 C8 24      \n");
    Z = A;
    N = A;
    V = 0;
    memory[0xc824] = A;
                                                     mon("         JMP   Check0Ref               ; 174E: 7E F3 4F      \n");
    PC = 0xf34f;
    JUMP;
    
  case 0x1751:                                       mon("L1751    CMPD  #$7F                    ; 1751: 10 83 00 7F   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x007f);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x007f)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $177E                   ; 1755: 2E 27         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x177e;
    JUMP;
    }
                                                     mon("         CMPD  #$FF81                  ; 1757: 10 83 FF 81   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xff81);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xff81)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $177E                   ; 175B: 2D 21         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x177e;
    JUMP;
    }
                                                     mon("         CMPY  #$7F                    ; 175D: 10 8C 00 7F   \n");
    res = (Y) - (0x007f);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = (((Y) ^ (0x007f)) & ((Y) ^ res)) >> 8;
                                                     mon("         BGT   $177E                   ; 1761: 2E 1B         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x177e;
    JUMP;
    }
                                                     mon("         CMPY  #$FF81                  ; 1763: 10 8C FF 81   \n");
    res = (Y) - (0xff81);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = (((Y) ^ (0xff81)) & ((Y) ^ res)) >> 8;
                                                     mon("         BLT   $177E                   ; 1767: 2D 15         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x177e;
    JUMP;
    }
                                                     mon("         PSHS  Y                       ; 1769: 34 20         \n");
    memory[--S] = Y & 0xff; memory[--S] = Y >> 8;
                                                     mon("         LDA   ,S+                     ; 176B: A6 E0         \n");
    A = (UINT8)memory[S];
 // N = A;
 // Z = A;
 // V = 0;
    S = S + 1;
                                                     mon("         LDA   ,S+                     ; 176D: A6 E0         \n");
    A = (UINT8)memory[S];
 // N = A;
 // Z = A;
 // V = 0;
    S = S + 1;
  case 0x176F:                                       mon("L176F    PSHS  B,A                     ; 176F: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   ,S++                    ; 1771: EC E1         \n");
    A = memory[S];
    B = memory[(UINT16)((S)+1)];
    Z = A|B;
    N = A;
 // V = 0;
    S = S + 2;
                                                     mon("         BEQ   $177B                   ; 1773: 27 06         \n");
    if (!Z) {
    PC = 0x177b;
    JUMP;
    }
                                                     mon("         JSR   Rise_Run_Angle          ; 1775: BD F5 93      \n");
    memory[--S] = 0x1778 & 0xff; memory[--S] = 0x1778 >> 8;
    PC = 0xf593;
    JUMP;
  case 0x1778:                                       mon("L1778    ANDCC #$FD                    ; 1778: 1C FD         \n");
    V = 0;
                                                     mon("         RTS                           ; 177A: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x177B:                                       mon("L177B    ORCC  #$02                    ; 177B: 1A 02         \n");
    V = 1;
                                                     mon("         RTS                           ; 177D: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x177E:                                       mon("L177E    ASRA                          ; 177E: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 177F: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
 // C = res & 1;
    res = (UINT8)(res >> 1);
 // Z = res;
 // N = res;
    B = res;
                                                     mon("         EXG   D,Y                     ; 1780: 1E 02         \n");
    val = ((A << 8) | B);
    A = (UINT8)((Y) >> 8);
    B = (UINT8)((Y) & 0xff);
    Y = val;
                                                     mon("         ASRA                          ; 1782: 47            \n");
    C = A & 1;
    A = (UINT8)((SINT8)A >> 1);
 // Z = A;
 // N = A;
                                                     mon("         RORB                          ; 1783: 56            \n");
    res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
    C = res & 1;
    res = (UINT8)(res >> 1);
    Z = res;
    N = res;
    B = res;
                                                     mon("         EXG   D,Y                     ; 1784: 1E 02         \n");
    val = ((A << 8) | B);
    A = (UINT8)((Y) >> 8);
    B = (UINT8)((Y) & 0xff);
    Y = val;
                                                     mon("         BRA   $1751                   ; 1786: 20 C9         \n");
    PC = 0x1751;
    JUMP;
    
                                                     mon("         LDB   $08,U                   ; 1788: E6 48         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0008)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 178A: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  $00,U                   ; 178B: E3 40         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[(UINT16)(U + 0x0000)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0000))+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[(UINT16)(U + 0x0000)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0000))+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 178D: ED 40         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         SUBD  <$80                    ; 178F: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$C0                    ; 1791: 10 83 00 C0   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x00c0);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x00c0)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $17C6                   ; 1795: 2E 2F         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x17c6;
    JUMP;
    }
                                                     mon("         CMPD  #$FF40                  ; 1797: 10 83 FF 40   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xff40);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xff40)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $17C6                   ; 179B: 2D 29         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x17c6;
    JUMP;
    }
                                                     mon("         LDB   $09,U                   ; 179D: E6 49         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0009)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 179F: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  $04,U                   ; 17A0: E3 44         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[(UINT16)(U + 0x0004)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0004))+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[(UINT16)(U + 0x0004)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0004))+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 17A2: ED 44         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         SUBD  <$84                    ; 17A4: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  #$C0                    ; 17A6: 10 83 00 C0   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0x00c0);
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0x00c0)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $17C6                   ; 17AA: 2E 1A         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x17c6;
    JUMP;
    }
                                                     mon("         CMPD  #$FF40                  ; 17AC: 10 83 FF 40   \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (0xff40);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (0xff40)) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BLT   $17C6                   ; 17B0: 2D 14         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x17c6;
    JUMP;
    }
                                                     mon("         LDA   $07,U                   ; 17B2: A6 47         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0007)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$00                    ; 17B4: 81 00         \n");
    res = A - (SINT8)0x00;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x00) & (A ^ (UINT8)res);
                                                     mon("         BEQ   $17C0                   ; 17B6: 27 08         \n");
    if (!Z) {
    PC = 0x17c0;
    JUMP;
    }
                                                     mon("         LDD   #$03                    ; 17B8: CC 00 03      \n");
    A = (UINT8)((0x0003) >> 8);
    B = (UINT8)((0x0003) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $12A4                   ; 17BB: BD 12 A4      \n");
    memory[--S] = 0x17be & 0xff; memory[--S] = 0x17be >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x17BE:                                       mon("L17BE    BCS   $17C1                   ; 17BE: 25 01         \n");
    if (C) {
    PC = 0x17c1;
    JUMP;
    }
  case 0x17C0:                                       mon("L17C0    RTS                           ; 17C0: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x17C1:                                       mon("L17C1    LDA   #$99                    ; 17C1: 86 99         \n");
    A = (UINT8)(SINT8)0x99;
    N = A;
    Z = A;
    V = 0;
                                                     mon("         JSR   $0FE1                   ; 17C3: BD 0F E1      \n");
    memory[--S] = 0x17c6 & 0xff; memory[--S] = 0x17c6 >> 8;
    PC = 0x0fe1;
    JUMP;
  case 0x17C6:                                       mon("L17C6    JMP   $119F                   ; 17C6: 7E 11 9F      \n");
    PC = 0x119f;
    JUMP;
    
                                                     mon("         LDD   #$05                    ; 17C9: CC 00 05      \n");
    A = (UINT8)((0x0005) >> 8);
    B = (UINT8)((0x0005) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12A4                   ; 17CC: BD 12 A4      \n");
    memory[--S] = 0x17cf & 0xff; memory[--S] = 0x17cf >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x17CF:                                       mon("L17CF    BCC   $17DF                   ; 17CF: 24 0E         \n");
    if (!C) {
    PC = 0x17df;
    JUMP;
    }
                                                     mon("         LDA   $0B,U                   ; 17D1: A6 4B         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   #$B0                    ; 17D3: 8A B0         \n");
    A = A | (SINT8)0xb0;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ANDA  #$BF                    ; 17D5: 84 BF         \n");
    A = A & (SINT8)0xbf;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 17D7: A7 4B         \n");
    Z = A;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
                                                     mon("         JSR   $0F91                   ; 17D9: BD 0F 91      \n");
    memory[--S] = 0x17dc & 0xff; memory[--S] = 0x17dc >> 8;
    PC = 0x0f91;
    JUMP;
  case 0x17DC:                                       mon("L17DC    JMP   $1848                   ; 17DC: 7E 18 48      \n");
    PC = 0x1848;
    JUMP;
    
  case 0x17DF:                                       mon("L17DF    LDA   <$26                    ; 17DF: 96 26         \n");
    A = (UINT8)memory_DP[0x26];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  #$01                    ; 17E1: 85 01         \n");
    res = A & (SINT8)0x01;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $1823                   ; 17E3: 26 3E         \n");
    if (Z) {
    PC = 0x1823;
    JUMP;
    }
                                                     mon("         LDD   #$01E0                  ; 17E5: CC 01 E0      \n");
    A = (UINT8)((0x01e0) >> 8);
    B = (UINT8)((0x01e0) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $12A4                   ; 17E8: BD 12 A4      \n");
    memory[--S] = 0x17eb & 0xff; memory[--S] = 0x17eb >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x17EB:                                       mon("L17EB    LBCC  $119F                   ; 17EB: 10 24 F9 B0   \n");
    if (!C) {
    PC = 0x119f;
    JUMP;
    }
                                                     mon("         JSR   $10F6                   ; 17EF: BD 10 F6      \n");
    memory[--S] = 0x17f2 & 0xff; memory[--S] = 0x17f2 >> 8;
    PC = 0x10f6;
    JUMP;
  case 0x17F2:                                       mon("L17F2    LSRB                          ; 17F2: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 17F3: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         LSRB                          ; 17F4: 54            \n");
 // C = (B) & 1;
    B = (B) >> 1;
 // N = 0;
 // Z = B;
                                                     mon("         SEX                           ; 17F5: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         PSHS  B,A                     ; 17F6: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         LDD   $02,U                   ; 17F8: EC 42         \n");
    A = memory[(UINT16)(U + 0x0002)];
    B = memory[(UINT16)(((UINT16)(U + 0x0002))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$82                    ; 17FA: 93 82         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
    N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         BPL   $1801                   ; 17FC: 2A 03         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1801;
    JUMP;
    }
                                                     mon("         JSR   $19CB                   ; 17FE: BD 19 CB      \n");
    memory[--S] = 0x1801 & 0xff; memory[--S] = 0x1801 >> 8;
    PC = 0x19cb;
    JUMP;
  case 0x1801:                                       mon("L1801    CMPD  ,S++                    ; 1801: 10 A3 E1      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory[S]<<8)|memory[(UINT16)((S)+1)]));
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory[S]<<8)|memory[(UINT16)((S)+1)]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
    S = S + 2;
                                                     mon("         BLE   $1824                   ; 1804: 2F 1E         \n");
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x1824;
    JUMP;
    }
                                                     mon("         LDD   $02,U                   ; 1806: EC 42         \n");
    A = memory[(UINT16)(U + 0x0002)];
    B = memory[(UINT16)(((UINT16)(U + 0x0002))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         CMPD  <$82                    ; 1808: 10 93 82      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $1817                   ; 180B: 2E 0A         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x1817;
    JUMP;
    }
                                                     mon("         ADDD  #$03                    ; 180D: C3 00 03      \n");
    arg = (A << 8) | B;
    res = arg + 0x0003;
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((0x0003) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  <$82                    ; 1810: 10 93 82      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGT   $181F                   ; 1813: 2E 0A         \n");
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x181f;
    JUMP;
    }
                                                     mon("         BRA   $1821                   ; 1815: 20 0A         \n");
    PC = 0x1821;
    JUMP;
    
  case 0x1817:                                       mon("L1817    SUBD  #$03                    ; 1817: 83 00 03      \n");
    arg = (A << 8) | B;
    res = arg - (0x0003);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (0x0003)) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         CMPD  <$82                    ; 181A: 10 93 82      \n");
    res = ((((UINT8)A<<8)|(UINT8)B)) - (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]));
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
    N = res >> 8;
    V = ((((((UINT8)A<<8)|(UINT8)B)) ^ (((memory_DP[0x82]<<8)|memory_DP[0x82 + 1]))) & (((((UINT8)A<<8)|(UINT8)B)) ^ res)) >> 8;
                                                     mon("         BGE   $1821                   ; 181D: 2C 02         \n");
    if ((SINT8)(N^V) >= 0) {
    PC = 0x1821;
    JUMP;
    }
  case 0x181F:                                       mon("L181F    LDD   <$82                    ; 181F: DC 82         \n");
    A = memory_DP[0x82];
    B = memory_DP[0x82 + 1];
 // Z = A|B;
 // N = A;
 // V = 0;
  case 0x1821:                                       mon("L1821    STD   $02,U                   ; 1821: ED 42         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
  case 0x1823:                                       mon("L1823    RTS                           ; 1823: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x1824:                                       mon("L1824    LDD   $00,U                   ; 1824: EC 40         \n");
    A = memory[(UINT16)(U + 0x0000)];
    B = memory[(UINT16)(((UINT16)(U + 0x0000))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 1826: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         TFR   D,Y                     ; 1828: 1F 02         \n");
    Y = ((A << 8) | B);
                                                     mon("         LDD   $04,U                   ; 182A: EC 44         \n");
    A = memory[(UINT16)(U + 0x0004)];
    B = memory[(UINT16)(((UINT16)(U + 0x0004))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 182C: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         JSR   $1751                   ; 182E: BD 17 51      \n");
    memory[--S] = 0x1831 & 0xff; memory[--S] = 0x1831 >> 8;
    PC = 0x1751;
    JUMP;
  case 0x1831:                                       mon("L1831    ADDA  #$10                    ; 1831: 8B 10         \n");
    res = A + (SINT8)0x10;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         LDB   #$04                    ; 1833: C6 04         \n");
    B = (UINT8)(SINT8)0x04;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         STD   <$97                    ; 1835: DD 97         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory_DP[0x97] = A;
    memory_DP[0x97 + 1] = B;
                                                     mon("         LDD   #$60                    ; 1837: CC 00 60      \n");
    A = (UINT8)((0x0060) >> 8);
    B = (UINT8)((0x0060) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12A4                   ; 183A: BD 12 A4      \n");
    memory[--S] = 0x183d & 0xff; memory[--S] = 0x183d >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x183D:                                       mon("L183D    BCS   $1848                   ; 183D: 25 09         \n");
    if (C) {
    PC = 0x1848;
    JUMP;
    }
                                                     mon("         LDB   $0B,U                   ; 183F: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDB  #$0F                    ; 1841: C4 0F         \n");
    B = B & (SINT8)0x0f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   $0B,U                   ; 1843: E7 4B         \n");
    Z = B;
    N = B;
    V = 0;
    memory[(UINT16)(U + 0x000b)] = B;
                                                     mon("         JMP   $191C                   ; 1845: 7E 19 1C      \n");
    PC = 0x191c;
    JUMP;
    
  case 0x1848:                                       mon("L1848    LDA   #$01                    ; 1848: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$98                    ; 184A: 97 98         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x98] = A;
                                                     mon("         LDB   <$97                    ; 184C: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  $06,U                   ; 184E: E0 46         \n");
    res = B - memory[(UINT16)(U + 0x0006)];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory[(UINT16)(U + 0x0006)]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ANDB  #$3F                    ; 1850: C4 3F         \n");
    B = B & (SINT8)0x3f;
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BNE   $18A6                   ; 1852: 26 52         \n");
    if (Z) {
    PC = 0x18a6;
    JUMP;
    }
                                                     mon("         LDB   <$F1                    ; 1854: D6 F1         \n");
    B = (UINT8)memory_DP[0xf1];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         CMPB  #$02                    ; 1856: C1 02         \n");
    res = B - (SINT8)0x02;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x02) & (B ^ (UINT8)res);
                                                     mon("         BCC   $1866                   ; 1858: 24 0C         \n");
    if (!C) {
    PC = 0x1866;
    JUMP;
    }
                                                     mon("         LDB   <$97                    ; 185A: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBB  <$86                    ; 185C: D0 86         \n");
    res = B - memory_DP[0x86];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((B) ^ memory_DP[0x86]) & ((B) ^ (UINT8)res);
    B = (UINT8)(res);
                                                     mon("         ADDB  #$03                    ; 185E: CB 03         \n");
    res = B + (SINT8)0x03;
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = B ^ (SINT8)0x03 ^ (UINT8)res ^ C;
 // V = B ^ (SINT8)0x03 ^ (UINT8)res ^ C;
    B = (UINT8)res;
                                                     mon("         ANDB  #$3F                    ; 1860: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         CMPB  #$06                    ; 1862: C1 06         \n");
    res = B - (SINT8)0x06;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x06) & (B ^ (UINT8)res);
                                                     mon("         BHI   $18A6                   ; 1864: 22 40         \n");
    if (Z && (!C)) {
    PC = 0x18a6;
    JUMP;
    }
  case 0x1866:                                       mon("L1866    LDA   $0B,U                   ; 1866: A6 4B         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000b)];
    N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BPL   $18A6                   ; 1868: 2A 3C         \n");
    if ((SINT8)N >= 0) {
    PC = 0x18a6;
    JUMP;
    }
                                                     mon("         BITA  #$40                    ; 186A: 85 40         \n");
    res = A & (SINT8)0x40;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $18A6                   ; 186C: 26 38         \n");
    if (Z) {
    PC = 0x18a6;
    JUMP;
    }
                                                     mon("         ANDA  #$0F                    ; 186E: 84 0F         \n");
    A = A & (SINT8)0x0f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   <$9E                    ; 1870: 97 9E         \n");
    Z = A;
 // N = A;
 // V = 0;
    memory_DP[0x9e] = A;
                                                     mon("         BEQ   $189E                   ; 1872: 27 2A         \n");
    if (!Z) {
    PC = 0x189e;
    JUMP;
    }
                                                     mon("         TFR   U,Y                     ; 1874: 1F 32         \n");
    Y = U;
                                                     mon("         LDA   #$01                    ; 1876: 86 01         \n");
    A = (UINT8)(SINT8)0x01;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         JSR   $1149                   ; 1878: BD 11 49      \n");
    memory[--S] = 0x187b & 0xff; memory[--S] = 0x187b >> 8;
    PC = 0x1149;
    JUMP;
  case 0x187B:                                       mon("L187B    EXG   U,Y                     ; 187B: 1E 32         \n");
    val = U;
    U = Y;
    Y = val;
                                                     mon("         BCS   $189E                   ; 187D: 25 1F         \n");
    if (C) {
    PC = 0x189e;
    JUMP;
    }
                                                     mon("         LDD   #$060F                  ; 187F: CC 06 0F      \n");
    A = (UINT8)((0x060f) >> 8);
    B = (UINT8)((0x060f) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STB   <$D7                    ; 1882: D7 D7         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory_DP[0xd7] = B;
                                                     mon("         EXG   X,Y                     ; 1884: 1E 12         \n");
    val = X;
    X = Y;
    Y = val;
                                                     mon("         JSR   Move_Mem_a              ; 1886: BD F6 83      \n");
    memory[--S] = 0x1889 & 0xff; memory[--S] = 0x1889 >> 8;
    PC = 0xf683;
    JUMP;
  case 0x1889:                                       mon("L1889    EXG   Y,X                     ; 1889: 1E 21         \n");
    val = Y;
    Y = X;
    X = val;
                                                     mon("         LDA   #$04                    ; 188B: 86 04         \n");
    A = (UINT8)(SINT8)0x04;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   <$97                    ; 188D: D6 97         \n");
    B = (UINT8)memory_DP[0x97];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         JSR   Rise_Run_Y              ; 188F: BD F6 01      \n");
    memory[--S] = 0x1892 & 0xff; memory[--S] = 0x1892 >> 8;
    PC = 0xf601;
    JUMP;
  case 0x1892:                                       mon("L1892    STD   $08,Y                   ; 1892: ED 28         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(Y + 0x0008)] = A;
    memory[(UINT16)(Y + 0x0008) + 1] = B;
                                                     mon("         DEC   <$9E                    ; 1894: 0A 9E         \n");
    res = (UINT8)(memory_DP[0x9e] - 1);
 // N = res;
 // Z = res;
 // V = memory_DP[0x9e] & ~res;
    memory_DP[0x9e] = res;
                                                     mon("         LDA   $0B,U                   ; 1896: A6 4B         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ORA   #$70                    ; 1898: 8A 70         \n");
    A = A | (SINT8)0x70;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ANDA  #$70                    ; 189A: 84 70         \n");
    A = A & (SINT8)0x70;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 189C: A7 4B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
  case 0x189E:                                       mon("L189E    LDA   $0B,U                   ; 189E: A6 4B         \n");
    A = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         ANDA  #$F0                    ; 18A0: 84 F0         \n");
    A = A & (SINT8)0xf0;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         ORA   <$9E                    ; 18A2: 9A 9E         \n");
    A = A | memory_DP[0x9e];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 18A4: A7 4B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
  case 0x18A6:                                       mon("L18A6    LDB   $0B,U                   ; 18A6: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         LDA   <$97                    ; 18A8: 96 97         \n");
    A = (UINT8)memory_DP[0x97];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         SUBA  $06,U                   ; 18AA: A0 46         \n");
    res = A - memory[(UINT16)(U + 0x0006)];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[(UINT16)(U + 0x0006)]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
                                                     mon("         ADDA  #$10                    ; 18AC: 8B 10         \n");
    res = A + (SINT8)0x10;
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         ANDA  #$3F                    ; 18AE: 84 3F         \n");
    A = A & (SINT8)0x3f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         CMPA  #$20                    ; 18B0: 81 20         \n");
    res = A - (SINT8)0x20;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x20) & (A ^ (UINT8)res);
                                                     mon("         BHI   $18B6                   ; 18B2: 22 02         \n");
    if (Z && (!C)) {
    PC = 0x18b6;
    JUMP;
    }
                                                     mon("         ANDB  #$BF                    ; 18B4: C4 BF         \n");
    B = B & (SINT8)0xbf;
 // Z = B;
 // N = B;
 // V = 0;
  case 0x18B6:                                       mon("L18B6    TSTB                          ; 18B6: 5D            \n");
 // Z = B;
    N = B;
 // V = 0;
                                                     mon("         BPL   $18BD                   ; 18B7: 2A 04         \n");
    if ((SINT8)N >= 0) {
    PC = 0x18bd;
    JUMP;
    }
                                                     mon("         LDA   #$0A                    ; 18B9: 86 0A         \n");
    A = (UINT8)(SINT8)0x0a;
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         STA   <$BF                    ; 18BB: 97 BF         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory_DP[0xbf] = A;
  case 0x18BD:                                       mon("L18BD    BITB  #$C0                    ; 18BD: C5 C0         \n");
    res = B & (SINT8)0xc0;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $18CF                   ; 18BF: 26 0E         \n");
    if (Z) {
    PC = 0x18cf;
    JUMP;
    }
                                                     mon("         LDA   $CA4B                   ; 18C1: B6 CA 4B      \n");
    A = (UINT8)memory[0xca4b];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         CMPA  #$04                    ; 18C4: 81 04         \n");
    res = A - (SINT8)0x04;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x04) & (A ^ (UINT8)res);
                                                     mon("         BCS   $18CD                   ; 18C6: 25 05         \n");
    if (C) {
    PC = 0x18cd;
    JUMP;
    }
                                                     mon("         JSR   Random                  ; 18C8: BD F5 17      \n");
    memory[--S] = 0x18cb & 0xff; memory[--S] = 0x18cb >> 8;
    PC = 0xf517;
    JUMP;
  case 0x18CB:                                       mon("L18CB    BNE   $18CF                   ; 18CB: 26 02         \n");
    if (Z) {
    PC = 0x18cf;
    JUMP;
    }
  case 0x18CD:                                       mon("L18CD    ORB   #$80                    ; 18CD: CA 80         \n");
    B = B | (SINT8)0x80;
 // Z = B;
 // N = B;
 // V = 0;
  case 0x18CF:                                       mon("L18CF    STB   $0B,U                   ; 18CF: E7 4B         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = B;
                                                     mon("         LDD   #$20                    ; 18D1: CC 00 20      \n");
    A = (UINT8)((0x0020) >> 8);
    B = (UINT8)((0x0020) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12A4                   ; 18D4: BD 12 A4      \n");
    memory[--S] = 0x18d7 & 0xff; memory[--S] = 0x18d7 >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x18D7:                                       mon("L18D7    BCC   $18ED                   ; 18D7: 24 14         \n");
    if (!C) {
    PC = 0x18ed;
    JUMP;
    }
                                                     mon("         LDB   $0B,U                   ; 18D9: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BPL   $18E7                   ; 18DB: 2A 0A         \n");
    if ((SINT8)N >= 0) {
    PC = 0x18e7;
    JUMP;
    }
                                                     mon("         BITB  #$40                    ; 18DD: C5 40         \n");
    res = B & (SINT8)0x40;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $18E7                   ; 18DF: 26 06         \n");
    if (Z) {
    PC = 0x18e7;
    JUMP;
    }
                                                     mon("         CLR   <$98                    ; 18E1: 0F 98         \n");
    memory_DP[0x98] = 0;
 // V = 0;
 // Z = 0;
 // N = 0;
    C = 0;
                                                     mon("         ANDB  #$CF                    ; 18E3: C4 CF         \n");
    B = B & (SINT8)0xcf;
    Z = B;
    N = B;
    V = 0;
                                                     mon("         BRA   $18E9                   ; 18E5: 20 02         \n");
    PC = 0x18e9;
    JUMP;
    
  case 0x18E7:                                       mon("L18E7    ORB   #$30                    ; 18E7: CA 30         \n");
    B = B | (SINT8)0x30;
 // Z = B;
 // N = B;
 // V = 0;
  case 0x18E9:                                       mon("L18E9    STB   $0B,U                   ; 18E9: E7 4B         \n");
    Z = B;
    N = B;
    V = 0;
    memory[(UINT16)(U + 0x000b)] = B;
                                                     mon("         BRA   $191C                   ; 18EB: 20 2F         \n");
    PC = 0x191c;
    JUMP;
    
  case 0x18ED:                                       mon("L18ED    LDB   $0B,U                   ; 18ED: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BPL   $18F7                   ; 18EF: 2A 06         \n");
    if ((SINT8)N >= 0) {
    PC = 0x18f7;
    JUMP;
    }
                                                     mon("         ANDB  #$CF                    ; 18F1: C4 CF         \n");
    B = B & (SINT8)0xcf;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   $0B,U                   ; 18F3: E7 4B         \n");
    Z = B;
    N = B;
    V = 0;
    memory[(UINT16)(U + 0x000b)] = B;
                                                     mon("         BRA   $191C                   ; 18F5: 20 25         \n");
    PC = 0x191c;
    JUMP;
    
  case 0x18F7:                                       mon("L18F7    ANDB  #$30                    ; 18F7: C4 30         \n");
    B = B & (SINT8)0x30;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         CMPB  #$30                    ; 18F9: C1 30         \n");
    res = B - (SINT8)0x30;
    C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x30) & (B ^ (UINT8)res);
                                                     mon("         BNE   $190C                   ; 18FB: 26 0F         \n");
    if (Z) {
    PC = 0x190c;
    JUMP;
    }
                                                     mon("         JSR   Random                  ; 18FD: BD F5 17      \n");
    memory[--S] = 0x1900 & 0xff; memory[--S] = 0x1900 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x1900:                                       mon("L1900    BITA  #$F7                    ; 1900: 85 F7         \n");
    res = A & (SINT8)0xf7;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $191C                   ; 1902: 26 18         \n");
    if (Z) {
    PC = 0x191c;
    JUMP;
    }
                                                     mon("         LDB   $0B,U                   ; 1904: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDB  #$CF                    ; 1906: C4 CF         \n");
    B = B & (SINT8)0xcf;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   $0B,U                   ; 1908: E7 4B         \n");
    Z = B;
    N = B;
    V = 0;
    memory[(UINT16)(U + 0x000b)] = B;
                                                     mon("         BRA   $191C                   ; 190A: 20 10         \n");
    PC = 0x191c;
    JUMP;
    
  case 0x190C:                                       mon("L190C    TSTB                          ; 190C: 5D            \n");
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BNE   $191C                   ; 190D: 26 0D         \n");
    if (Z) {
    PC = 0x191c;
    JUMP;
    }
                                                     mon("         JSR   Random                  ; 190F: BD F5 17      \n");
    memory[--S] = 0x1912 & 0xff; memory[--S] = 0x1912 >> 8;
    PC = 0xf517;
    JUMP;
  case 0x1912:                                       mon("L1912    ANDA  #$20                    ; 1912: 84 20         \n");
    A = A & (SINT8)0x20;
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BNE   $1918                   ; 1914: 26 02         \n");
    if (Z) {
    PC = 0x1918;
    JUMP;
    }
                                                     mon("         ORA   #$10                    ; 1916: 8A 10         \n");
    A = A | (SINT8)0x10;
 // Z = A;
 // N = A;
 // V = 0;
  case 0x1918:                                       mon("L1918    ORA   $0B,U                   ; 1918: AA 4B         \n");
    A = A | memory[(UINT16)(U + 0x000b)];
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         STA   $0B,U                   ; 191A: A7 4B         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x000b)] = A;
  case 0x191C:                                       mon("L191C    LDA   <$97                    ; 191C: 96 97         \n");
    A = (UINT8)memory_DP[0x97];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $0B,U                   ; 191E: E6 4B         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000b)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDB  #$30                    ; 1920: C4 30         \n");
    B = B & (SINT8)0x30;
    Z = B;
 // N = B;
 // V = 0;
                                                     mon("         BEQ   $1936                   ; 1922: 27 12         \n");
    if (!Z) {
    PC = 0x1936;
    JUMP;
    }
                                                     mon("         CMPB  #$30                    ; 1924: C1 30         \n");
    res = B - (SINT8)0x30;
 // C = res & 0x100;
    Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (B ^ (SINT8)0x30) & (B ^ (UINT8)res);
                                                     mon("         BNE   $192C                   ; 1926: 26 04         \n");
    if (Z) {
    PC = 0x192c;
    JUMP;
    }
                                                     mon("         ADDA  #$20                    ; 1928: 8B 20         \n");
    res = A + (SINT8)0x20;
    C = (res >> 1) & 0x80;
    Z = (UINT8)res;
    N = (UINT8)res;
    H = A ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    V = A ^ (SINT8)0x20 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         BRA   $1936                   ; 192A: 20 0A         \n");
    PC = 0x1936;
    JUMP;
    
  case 0x192C:                                       mon("L192C    BITA  #$20                    ; 192C: 85 20         \n");
    res = A & (SINT8)0x20;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BEQ   $1934                   ; 192E: 27 04         \n");
    if (!Z) {
    PC = 0x1934;
    JUMP;
    }
                                                     mon("         ADDA  #$10                    ; 1930: 8B 10         \n");
    res = A + (SINT8)0x10;
    C = (res >> 1) & 0x80;
    Z = (UINT8)res;
    N = (UINT8)res;
    H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         BRA   $1936                   ; 1932: 20 02         \n");
    PC = 0x1936;
    JUMP;
    
  case 0x1934:                                       mon("L1934    SUBA  #$10                    ; 1934: 80 10         \n");
    res = A - (SINT8)0x10;
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ (SINT8)0x10) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
  case 0x1936:                                       mon("L1936    LDB   <$98                    ; 1936: D6 98         \n");
    B = (UINT8)memory_DP[0x98];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         ANDA  #$3F                    ; 1938: 84 3F         \n");
    A = A & (SINT8)0x3f;
 // Z = A;
 // N = A;
 // V = 0;
                                                     mon("         PSHS  B,A                     ; 193A: 34 06         \n");
    memory[--S] = B;
    memory[--S] = A;
                                                     mon("         JSR   Random                  ; 193C: BD F5 17      \n");
    memory[--S] = 0x193f & 0xff; memory[--S] = 0x193f >> 8;
    PC = 0xf517;
    JUMP;
  case 0x193F:                                       mon("L193F    LDB   #$02                    ; 193F: C6 02         \n");
    B = (UINT8)(SINT8)0x02;
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         MUL                           ; 1941: 3D            \n");
    res = (UINT16)(A * B);
 // Z = res;
    C = res & 0x80; /* ??? 8000 ??? */
    A = res >> 8;
    B = (UINT8)res;
                                                     mon("         ADCA  #$00                    ; 1942: 89 00         \n");
    res = A + (SINT8)0x00 + (C != 0 ? 1:0);
 // C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // H = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
 // V = A ^ (SINT8)0x00 ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         DECA                          ; 1944: 4A            \n");
    res = (UINT8)(A - 1);
 // N = res;
 // Z = res;
 // V = A & ~res;
    A = res;
                                                     mon("         ADDA  ,S                      ; 1945: AB E4         \n");
    res = A + memory[S];
    C = (res >> 1) & 0x80;
 // Z = (UINT8)res;
 // N = (UINT8)res;
    H = A ^ memory[S] ^ (UINT8)res ^ C;
 // V = A ^ memory[S] ^ (UINT8)res ^ C;
    A = (UINT8)res;
                                                     mon("         STA   ,S                      ; 1947: A7 E4         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[S] = A;
                                                     mon("         LDA   $06,U                   ; 1949: A6 46         \n");
    A = (UINT8)memory[(UINT16)(U + 0x0006)];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         LDB   $06,U                   ; 194B: E6 46         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0006)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SUBA  ,S+                     ; 194D: A0 E0         \n");
    res = A - memory[S];
 // C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
    A = (UINT8)(res);
    S = S + 1;
                                                     mon("         ANDA  #$3F                    ; 194F: 84 3F         \n");
    A = A & (SINT8)0x3f;
    Z = A;
 // N = A;
 // V = 0;
                                                     mon("         BEQ   $195B                   ; 1951: 27 08         \n");
    if (!Z) {
    PC = 0x195b;
    JUMP;
    }
                                                     mon("         CMPA  #$20                    ; 1953: 81 20         \n");
    res = A - (SINT8)0x20;
    C = res & 0x100;
 // Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0x20) & (A ^ (UINT8)res);
                                                     mon("         BLT   $195A                   ; 1955: 2D 03         \n");
    if ((SINT8)(N^V) <  0) {
    PC = 0x195a;
    JUMP;
    }
                                                     mon("         INCB                          ; 1957: 5C            \n");
    res = (UINT8)(B + 1);
    Z = res;
    N = res;
    V = res & ~(B);
    B = res;
                                                     mon("         BRA   $195B                   ; 1958: 20 01         \n");
    PC = 0x195b;
    JUMP;
    
  case 0x195A:                                       mon("L195A    DECB                          ; 195A: 5A            \n");
    res = (UINT8)(B - 1);
 // N = res;
 // Z = res;
 // V = B & ~res;
    B = res;
  case 0x195B:                                       mon("L195B    ANDB  #$3F                    ; 195B: C4 3F         \n");
    B = B & (SINT8)0x3f;
 // Z = B;
 // N = B;
 // V = 0;
                                                     mon("         STB   $06,U                   ; 195D: E7 46         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x0006)] = B;
                                                     mon("         LDA   ,S+                     ; 195F: A6 E0         \n");
    A = (UINT8)memory[S];
 // N = A;
 // Z = A;
 // V = 0;
    S = S + 1;
                                                     mon("         JSR   Rise_Run_Y              ; 1961: BD F6 01      \n");
    memory[--S] = 0x1964 & 0xff; memory[--S] = 0x1964 >> 8;
    PC = 0xf601;
    JUMP;
  case 0x1964:                                       mon("L1964    STA   $08,U                   ; 1964: A7 48         \n");
 // Z = A;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0008)] = A;
                                                     mon("         STB   $0A,U                   ; 1966: E7 4A         \n");
 // Z = B;
 // N = B;
 // V = 0;
    memory[(UINT16)(U + 0x000a)] = B;
                                                     mon("         LDB   $0A,U                   ; 1968: E6 4A         \n");
    B = (UINT8)memory[(UINT16)(U + 0x000a)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 196A: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  $04,U                   ; 196B: E3 44         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[(UINT16)(U + 0x0004)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0004))+1)]);
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[(UINT16)(U + 0x0004)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0004))+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $04,U                   ; 196D: ED 44         \n");
 // Z = A | B;
 // N = A;
 // V = 0;
    memory[(UINT16)(U + 0x0004)] = A;
    memory[(UINT16)(U + 0x0004) + 1] = B;
                                                     mon("         LDB   $08,U                   ; 196F: E6 48         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0008)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 1971: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  $00,U                   ; 1972: E3 40         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[(UINT16)(U + 0x0000)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0000))+1)]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[(UINT16)(U + 0x0000)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0000))+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $00,U                   ; 1974: ED 40         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x0000)] = A;
    memory[(UINT16)(U + 0x0000) + 1] = B;
                                                     mon("         RTS                           ; 1976: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         LDD   #$C0                    ; 1977: CC 00 C0      \n");
    A = (UINT8)((0x00c0) >> 8);
    B = (UINT8)((0x00c0) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         JSR   $12A4                   ; 197A: BD 12 A4      \n");
    memory[--S] = 0x197d & 0xff; memory[--S] = 0x197d >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x197D:                                       mon("L197D    BCS   $199B                   ; 197D: 25 1C         \n");
    if (C) {
    PC = 0x199b;
    JUMP;
    }
                                                     mon("         LDD   $00,U                   ; 197F: EC 40         \n");
    A = memory[(UINT16)(U + 0x0000)];
    B = memory[(UINT16)(((UINT16)(U + 0x0000))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$80                    ; 1981: 93 80         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x80]<<8)|memory_DP[0x80 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         TFR   D,Y                     ; 1983: 1F 02         \n");
    Y = ((A << 8) | B);
                                                     mon("         LDD   $04,U                   ; 1985: EC 44         \n");
    A = memory[(UINT16)(U + 0x0004)];
    B = memory[(UINT16)(((UINT16)(U + 0x0004))+1)];
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         SUBD  <$84                    ; 1987: 93 84         \n");
    arg = (A << 8) | B;
    res = arg - (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]));
 // C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ (((memory_DP[0x84]<<8)|memory_DP[0x84 + 1]))) & (arg ^ res)) >> 8;
    A = (UINT8)(res >> 8);
 // N = res >> 8;
    B = (UINT8)(res & 0xff);
                                                     mon("         JSR   $1751                   ; 1989: BD 17 51      \n");
    memory[--S] = 0x198c & 0xff; memory[--S] = 0x198c >> 8;
    PC = 0x1751;
    JUMP;
  case 0x198C:                                       mon("L198C    LDB   <$ED                    ; 198C: D6 ED         \n");
    B = (UINT8)memory_DP[0xed];
    N = B;
 // Z = B;
 // V = 0;
                                                     mon("         BPL   $1997                   ; 198E: 2A 07         \n");
    if ((SINT8)N >= 0) {
    PC = 0x1997;
    JUMP;
    }
                                                     mon("         CMPA  #$20                    ; 1990: 81 20         \n");
    res = A - (SINT8)0x20;
    C = res & 0x100;
    Z = (UINT8)res;
    N = (UINT8)res;
    V = (A ^ (SINT8)0x20) & (A ^ (UINT8)res);
                                                     mon("         BCC   $199B                   ; 1992: 24 07         \n");
    if (!C) {
    PC = 0x199b;
    JUMP;
    }
  case 0x1994:                                       mon("L1994    JMP   $119F                   ; 1994: 7E 11 9F      \n");
    PC = 0x119f;
    JUMP;
    
  case 0x1997:                                       mon("L1997    CMPA  #$20                    ; 1997: 81 20         \n");
    res = A - (SINT8)0x20;
    C = res & 0x100;
 // Z = (UINT8)res;
 // N = (UINT8)res;
 // V = (A ^ (SINT8)0x20) & (A ^ (UINT8)res);
                                                     mon("         BCC   $1994                   ; 1999: 24 F9         \n");
    if (!C) {
    PC = 0x1994;
    JUMP;
    }
  case 0x199B:                                       mon("L199B    LDD   #$04                    ; 199B: CC 00 04      \n");
    A = (UINT8)((0x0004) >> 8);
    B = (UINT8)((0x0004) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $12A4                   ; 199E: BD 12 A4      \n");
    memory[--S] = 0x19a1 & 0xff; memory[--S] = 0x19a1 >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x19A1:                                       mon("L19A1    BCC   $19A6                   ; 19A1: 24 03         \n");
    if (!C) {
    PC = 0x19a6;
    JUMP;
    }
                                                     mon("         JSR   $0F91                   ; 19A3: BD 0F 91      \n");
    memory[--S] = 0x19a6 & 0xff; memory[--S] = 0x19a6 >> 8;
    PC = 0x0f91;
    JUMP;
  case 0x19A6:                                       mon("L19A6    RTS                           ; 19A6: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                                                     mon("         LDA   <$26                    ; 19A7: 96 26         \n");
    A = (UINT8)memory_DP[0x26];
 // N = A;
 // Z = A;
 // V = 0;
                                                     mon("         BITA  #$03                    ; 19A9: 85 03         \n");
    res = A & (SINT8)0x03;
    Z = res;
 // N = res;
 // V = 0;
                                                     mon("         BNE   $19CA                   ; 19AB: 26 1D         \n");
    if (Z) {
    PC = 0x19ca;
    JUMP;
    }
                                                     mon("         LDD   #$C0                    ; 19AD: CC 00 C0      \n");
    A = (UINT8)((0x00c0) >> 8);
    B = (UINT8)((0x00c0) & 0xff);
    Z = A|B;
    N = A;
    V = 0;
                                                     mon("         JSR   $12A4                   ; 19B0: BD 12 A4      \n");
    memory[--S] = 0x19b3 & 0xff; memory[--S] = 0x19b3 >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x19B3:                                       mon("L19B3    LBCC  $119F                   ; 19B3: 10 24 F7 E8   \n");
    if (!C) {
    PC = 0x119f;
    JUMP;
    }
                                                     mon("         LDD   #$03                    ; 19B7: CC 00 03      \n");
    A = (UINT8)((0x0003) >> 8);
    B = (UINT8)((0x0003) & 0xff);
 // Z = A|B;
 // N = A;
 // V = 0;
                                                     mon("         STB   <$9E                    ; 19BA: D7 9E         \n");
    Z = B;
    N = B;
    V = 0;
    memory_DP[0x9e] = B;
                                                     mon("         JSR   $12A4                   ; 19BC: BD 12 A4      \n");
    memory[--S] = 0x19bf & 0xff; memory[--S] = 0x19bf >> 8;
    PC = 0x12a4;
    JUMP;
  case 0x19BF:                                       mon("L19BF    LBCS  $0F91                   ; 19BF: 10 25 F5 CE   \n");
    if (C) {
    PC = 0x0f91;
    JUMP;
    }
                                                     mon("         LDB   $09,U                   ; 19C3: E6 49         \n");
    B = (UINT8)memory[(UINT16)(U + 0x0009)];
 // N = B;
 // Z = B;
 // V = 0;
                                                     mon("         SEX                           ; 19C5: 1D            \n");
 // Z = B;
 // N = B & 0x80;
    A = ((B & 0x80) != 0) ? 0xff : 0;
                                                     mon("         ADDD  $02,U                   ; 19C6: E3 42         \n");
    arg = (A << 8) | B;
    res = arg + ((memory[(UINT16)(U + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0002))+1)]);
    C = res & 0x10000;
    res = (UINT16)res;
 // Z = res;
 // V = ((arg ^ res) & ((((memory[(UINT16)(U + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(U + 0x0002))+1)])) ^ res)) >> 8;
 // N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         STD   $02,U                   ; 19C8: ED 42         \n");
    Z = A | B;
    N = A;
    V = 0;
    memory[(UINT16)(U + 0x0002)] = A;
    memory[(UINT16)(U + 0x0002) + 1] = B;
  case 0x19CA:                                       mon("L19CA    RTS                           ; 19CA: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
  case 0x19CB:                                       mon("L19CB    COMA                          ; 19CB: 43            \n");
    A = A ^ 0xff;
 // Z = A;
 // N = A;
 // V = 0;
 // C = 256;
                                                     mon("         COMB                          ; 19CC: 53            \n");
    B = B ^ 0xff;
 // Z = B;
 // N = B;
 // V = 0;
 // C = 256;
                                                     mon("         ADDD  #$01                    ; 19CD: C3 00 01      \n");
    arg = (A << 8) | B;
    res = arg + 0x0001;
    C = res & 0x10000;
    res = (UINT16)res;
    Z = res;
    V = ((arg ^ res) & ((0x0001) ^ res)) >> 8;
    N = res >> 8;
    A = (UINT8)(res >> 8);
    B = (UINT8)(res & 0xff);
                                                     mon("         RTS                           ; 19D0: 39            \n");
    PC = memory[S++]<<8;
    PC |= memory[S++];
    JUMP;
    
                   // FCB   $FE                     ; 19D1: 
                   // FCB   $E8                     ; 19D2: 
                   // FCB   $FE                     ; 19D3: 
                   // FCB   $B6                     ; 19D4: 
                   // FCB   $A6                     ; 19D5: 
                   // FCB   $1A                     ; 19D6: 
                   // FCB   $06                     ; 19D7: 
                   // FCB   $A4                     ; 19D8: 
                   // FCB   $1A                     ; 19D9: 
                   // FCB   $06                     ; 19DA: 
                   // FCB   $A6                     ; 19DB: 
                   // FCB   $1A                     ; 19DC: 
                   // FCB   $78                     ; 19DD: 
                   // FCB   $A4                     ; 19DE: 
                   // FCB   $1A                     ; 19DF: 
                   // FCB   $07                     ; 19E0: 
                   // FCB   $A2                     ; 19E1: 
                   // FCB   $1A                     ; 19E2: 
                   // FCB   $07                     ; 19E3: 
                   // FCB   $A1                     ; 19E4: 
                   // FCB   $1A                     ; 19E5: 
                   // FCB   $07                     ; 19E6: 
                   // FCB   $9F                     ; 19E7: 
                   // FCB   $1A                     ; 19E8: 
                   // FCB   $07                     ; 19E9: 
                   // FCB   $9E                     ; 19EA: 
                   // FCB   $95                     ; 19EB: 
                   // FCB   $0E                     ; 19EC: 
                   // FCB   $6C                     ; 19ED: 
                   // FCB   $9F                     ; 19EE: 
                   // FCB   $93                     ; 19EF: 
                   // FCB   $07                     ; 19F0: 
                   // FCB   $7F                     ; 19F1: 
                   // FCB   $BF                     ; 19F2: 
                   // FCB   $BF                     ; 19F3: 
                   // FCB   $3F                     ; 19F4: 
                   // FCB   $1E                     ; 19F5: 
                   // FCB   $9A                     ; 19F6: 
                   // FCB   $0E                     ; 19F7: 
                   // FCB   $06                     ; 19F8: 
                   // FCB   $98                     ; 19F9: 
                   // FCB   $0E                     ; 19FA: 
                   // FCB   $06                     ; 19FB: 
                   // FCB   $9A                     ; 19FC: 
                   // FCB   $0E                     ; 19FD: 
                   // FCB   $7D                     ; 19FE: 
                   // FCB   $95                     ; 19FF: 
                   // FCB   $0E                     ; 1A00: 
                   // FCB   $19                     ; 1A01: 
                   // FCB   $96                     ; 1A02: 
                   // FCB   $0E                     ; 1A03: 
                   // FCB   $19                     ; 1A04: 
                   // FCB   $92                     ; 1A05: 
                   // FCB   $95                     ; 1A06: 
                   // FCB   $0E                     ; 1A07: 
                   // FCB   $1B                     ; 1A08: 
                   // FCB   $8A                     ; 1A09: 
                   // FCB   $93                     ; 1A0A: 
                   // FCB   $07                     ; 1A0B: 
                   // FCB   $7F                     ; 1A0C: 
                   // FCB   $00                     ; 1A0D: 
                   // FCB   $80                     ; 1A0E: 
                   // FCB   $FE                     ; 1A0F: 
                   // FCB   $E8                     ; 1A10: 
                   // FCB   $FE                     ; 1A11: 
                   // FCB   $B6                     ; 1A12: 
                   // FCB   $95                     ; 1A13: 
                   // FCB   $0E                     ; 1A14: 
                   // FCB   $0D                     ; 1A15: 
                   // FCB   $96                     ; 1A16: 
                   // FCB   $0E                     ; 1A17: 
                   // FCB   $0F                     ; 1A18: 
                   // FCB   $92                     ; 1A19: 
                   // FCB   $95                     ; 1A1A: 
                   // FCB   $0E                     ; 1A1B: 
                   // FCB   $13                     ; 1A1C: 
                   // FCB   $8A                     ; 1A1D: 
                   // FCB   $93                     ; 1A1E: 
                   // FCB   $07                     ; 1A1F: 
                   // FCB   $7F                     ; 1A20: 
                   // FCB   $00                     ; 1A21: 
                   // FCB   $80                     ; 1A22: 
                   // FCB   $FD                     ; 1A23: 
                   // FCB   $69                     ; 1A24: 
                   // FCB   $FE                     ; 1A25: 
                   // FCB   $B6                     ; 1A26: 
                   // FCB   $A8                     ; 1A27: 
                   // FCB   $AB                     ; 1A28: 
                   // FCB   $30                     ; 1A29: 
                   // FCB   $10                     ; 1A2A: 
                   // FCB   $00                     ; 1A2B: 
                   // FCB   $80                     ; 1A2C: 
                   // FCB   $27                     ; 1A2D: 
                   // FCB   $01                     ; 1A2E: 
                   // FCB   $00                     ; 1A2F: 
                   // FCB   $01                     ; 1A30: 
                   // FCB   $12                     ; 1A31: 
                   // FCB   $FF                     ; 1A32: 
                   // FCB   $00                     ; 1A33: 
                   // FCB   $03                     ; 1A34: 
                   // FCB   $FC                     ; 1A35: 
                   // FCB   $1E                     ; 1A36: 
                   // FCB   $C4                     ; 1A37: 
                   // FCB   $E6                     ; 1A38: 
                   // FCB   $20                     ; 1A39: 
                   // FCB   $52                     ; 1A3A: 
                   // FCB   $45                     ; 1A3B: 
                   // FCB   $44                     ; 1A3C: 
                   // FCB   $20                     ; 1A3D: 
                   // FCB   $41                     ; 1A3E: 
                   // FCB   $4C                     ; 1A3F: 
                   // FCB   $45                     ; 1A40: 
                   // FCB   $52                     ; 1A41: 
                   // FCB   $54                     ; 1A42: 
                   // FCB   $20                     ; 1A43: 
                   // FCB   $80                     ; 1A44: 
                   // FCB   $00                     ; 1A45: 
                   // FCB   $FC                     ; 1A46: 
                   // FCB   $1E                     ; 1A47: 
                   // FCB   $8E                     ; 1A48: 
                   // FCB   $E4                     ; 1A49: 
                   // FCB   $20                     ; 1A4A: 
                   // FCB   $20                     ; 1A4B: 
                   // FCB   $44                     ; 1A4C: 
                   // FCB   $4F                     ; 1A4D: 
                   // FCB   $43                     ; 1A4E: 
                   // FCB   $4B                     ; 1A4F: 
                   // FCB   $49                     ; 1A50: 
                   // FCB   $4E                     ; 1A51: 
                   // FCB   $47                     ; 1A52: 
                   // FCB   $20                     ; 1A53: 
                   // FCB   $20                     ; 1A54: 
                   // FCB   $20                     ; 1A55: 
                   // FCB   $80                     ; 1A56: 
                   // FCB   $00                     ; 1A57: 
                   // FCB   $F8                     ; 1A58: 
                   // FCB   $20                     ; 1A59: 
                   // FCB   $17                     ; 1A5A: 
                   // FCB   $EA                     ; 1A5B: 
                   // FCB   $53                     ; 1A5C: 
                   // FCB   $55                     ; 1A5D: 
                   // FCB   $42                     ; 1A5E: 
                   // FCB   $4D                     ; 1A5F: 
                   // FCB   $41                     ; 1A60: 
                   // FCB   $52                     ; 1A61: 
                   // FCB   $49                     ; 1A62: 
                   // FCB   $4E                     ; 1A63: 
                   // FCB   $45                     ; 1A64: 
                   // FCB   $80                     ; 1A65: 
                   // FCB   $F8                     ; 1A66: 
                   // FCB   $20                     ; 1A67: 
                   // FCB   $09                     ; 1A68: 
                   // FCB   $EA                     ; 1A69: 
                   // FCB   $20                     ; 1A6A: 
                   // FCB   $20                     ; 1A6B: 
                   // FCB   $52                     ; 1A6C: 
                   // FCB   $45                     ; 1A6D: 
                   // FCB   $41                     ; 1A6E: 
                   // FCB   $44                     ; 1A6F: 
                   // FCB   $59                     ; 1A70: 
                   // FCB   $80                     ; 1A71: 
                   // FCB   $F8                     ; 1A72: 
                   // FCB   $20                     ; 1A73: 
                   // FCB   $FB                     ; 1A74: 
                   // FCB   $EA                     ; 1A75: 
                   // FCB   $20                     ; 1A76: 
                   // FCB   $43                     ; 1A77: 
                   // FCB   $41                     ; 1A78: 
                   // FCB   $50                     ; 1A79: 
                   // FCB   $54                     ; 1A7A: 
                   // FCB   $41                     ; 1A7B: 
                   // FCB   $49                     ; 1A7C: 
                   // FCB   $4E                     ; 1A7D: 
                   // FCB   $80                     ; 1A7E: 
                   // FCB   $00                     ; 1A7F: 
                   // FCB   $7F                     ; 1A80: 
                   // FCB   $D0                     ; 1A81: 
                   // FCB   $4E                     ; 1A82: 
                   // FCB   $45                     ; 1A83: 
                   // FCB   $58                     ; 1A84: 
                   // FCB   $54                     ; 1A85: 
                   // FCB   $20                     ; 1A86: 
                   // FCB   $50                     ; 1A87: 
                   // FCB   $4C                     ; 1A88: 
                   // FCB   $41                     ; 1A89: 
                   // FCB   $59                     ; 1A8A: 
                   // FCB   $45                     ; 1A8B: 
                   // FCB   $52                     ; 1A8C: 
                   // FCB   $20                     ; 1A8D: 
                   // FCB   $52                     ; 1A8E: 
                   // FCB   $45                     ; 1A8F: 
                   // FCB   $41                     ; 1A90: 
                   // FCB   $44                     ; 1A91: 
                   // FCB   $59                     ; 1A92: 
                   // FCB   $80                     ; 1A93: 
                   // FCB   $7F                     ; 1A94: 
                   // FCB   $F1                     ; 1A95: 
                   // FCB   $50                     ; 1A96: 
                   // FCB   $41                     ; 1A97: 
                   // FCB   $55                     ; 1A98: 
                   // FCB   $53                     ; 1A99: 
                   // FCB   $45                     ; 1A9A: 
                   // FCB   $80                     ; 1A9B: 
                   // FCB   $7F                     ; 1A9C: 
                   // FCB   $D8                     ; 1A9D: 
                   // FCB   $52                     ; 1A9E: 
                   // FCB   $45                     ; 1A9F: 
                   // FCB   $50                     ; 1AA0: 
                   // FCB   $4C                     ; 1AA1: 
                   // FCB   $41                     ; 1AA2: 
                   // FCB   $59                     ; 1AA3: 
                   // FCB   $3A                     ; 1AA4: 
                   // FCB   $20                     ; 1AA5: 
                   // FCB   $41                     ; 1AA6: 
                   // FCB   $4E                     ; 1AA7: 
                   // FCB   $59                     ; 1AA8: 
                   // FCB   $20                     ; 1AA9: 
                   // FCB   $4B                     ; 1AAA: 
                   // FCB   $45                     ; 1AAB: 
                   // FCB   $59                     ; 1AAC: 
                   // FCB   $FD                     ; 1AAD: 
                   // FCB   $21                     ; 1AAE: 
                   // FCB   $AA                     ; 1AAF: 
                   // FCB   $E7                     ; 1AB0: 
                   // FCB   $4D                     ; 1AB1: 
                   // FCB   $2E                     ; 1AB2: 
                   // FCB   $49                     ; 1AB3: 
                   // FCB   $4E                     ; 1AB4: 
                   // FCB   $44                     ; 1AB5: 
                   // FCB   $49                     ; 1AB6: 
                   // FCB   $43                     ; 1AB7: 
                   // FCB   $54                     ; 1AB8: 
                   // FCB   $4F                     ; 1AB9: 
                   // FCB   $52                     ; 1ABA: 
                   // FCB   $80                     ; 1ABB: 
                   // FCB   $C8                     ; 1ABC: 
                   // FCB   $E4                     ; 1ABD: 
                   // FCB   $C8                     ; 1ABE: 
                   // FCB   $E5                     ; 1ABF: 
                   // FCB   $CA                     ; 1AC0: 
                   // FCB   $51                     ; 1AC1: 
                   // FCB   $CA                     ; 1AC2: 
                   // FCB   $5A                     ; 1AC3: 
                   // FCB   $17                     ; 1AC4: 
                   // FCB   $88                     ; 1AC5: 
                   // FCB   $1C                     ; 1AC6: 
                   // FCB   $9B                     ; 1AC7: 
                   // FCB   $17                     ; 1AC8: 
                   // FCB   $88                     ; 1AC9: 
                   // FCB   $1C                     ; 1ACA: 
                   // FCB   $7A                     ; 1ACB: 
                   // FCB   $19                     ; 1ACC: 
                   // FCB   $77                     ; 1ACD: 
                   // FCB   $1B                     ; 1ACE: 
                   // FCB   $FD                     ; 1ACF: 
                   // FCB   $17                     ; 1AD0: 
                   // FCB   $C9                     ; 1AD1: 
                   // FCB   $1C                     ; 1AD2: 
                   // FCB   $BC                     ; 1AD3: 
                   // FCB   $19                     ; 1AD4: 
                   // FCB   $A7                     ; 1AD5: 
                   // FCB   $1C                     ; 1AD6: 
                   // FCB   $52                     ; 1AD7: 
                   // FCB   $CA                     ; 1AD8: 
                   // FCB   $28                     ; 1AD9: 
                   // FCB   $00                     ; 1ADA: 
                   // FCB   $00                     ; 1ADB: 
                   // FCB   $CA                     ; 1ADC: 
                   // FCB   $31                     ; 1ADD: 
                   // FCB   $00                     ; 1ADE: 
                   // FCB   $01                     ; 1ADF: 
                   // FCB   $CA                     ; 1AE0: 
                   // FCB   $34                     ; 1AE1: 
                   // FCB   $00                     ; 1AE2: 
                   // FCB   $02                     ; 1AE3: 
                   // FCB   $CA                     ; 1AE4: 
                   // FCB   $3D                     ; 1AE5: 
                   // FCB   $00                     ; 1AE6: 
                   // FCB   $03                     ; 1AE7: 
                   // FCB   $CA                     ; 1AE8: 
                   // FCB   $42                     ; 1AE9: 
                   // FCB   $00                     ; 1AEA: 
                   // FCB   $04                     ; 1AEB: 
                   // FCB   $00                     ; 1AEC: 
                   // FCB   $00                     ; 1AED: 
                   // FCB   $02                     ; 1AEE: 
                   // FCB   $50                     ; 1AEF: 
                   // FCB   $02                     ; 1AF0: 
                   // FCB   $00                     ; 1AF1: 
                   // FCB   $05                     ; 1AF2: 
                   // FCB   $00                     ; 1AF3: 
                   // FCB   $01                     ; 1AF4: 
                   // FCB   $50                     ; 1AF5: 
                   // FCB   $04                     ; 1AF6: 
                   // FCB   $01                     ; 1AF7: 
                   // FCB   $04                     ; 1AF8: 
                   // FCB   $02                     ; 1AF9: 
                   // FCB   $04                     ; 1AFA: 
                   // FCB   $02                     ; 1AFB: 
                   // FCB   $0D                     ; 1AFC: 
                   // FCB   $34                     ; 1AFD: 
                   // FCB   $FF                     ; 1AFE: 
                   // FCB   $F0                     ; 1AFF: 
                   // FCB   $FC                     ; 1B00: 
                   // FCB   $FF                     ; 1B01: 
                   // FCB   $F0                     ; 1B02: 
                   // FCB   $04                     ; 1B03: 
                   // FCB   $FF                     ; 1B04: 
                   // FCB   $00                     ; 1B05: 
                   // FCB   $18                     ; 1B06: 
                   // FCB   $FF                     ; 1B07: 
                   // FCB   $10                     ; 1B08: 
                   // FCB   $04                     ; 1B09: 
                   // FCB   $FF                     ; 1B0A: 
                   // FCB   $10                     ; 1B0B: 
                   // FCB   $FC                     ; 1B0C: 
                   // FCB   $00                     ; 1B0D: 
                   // FCB   $00                     ; 1B0E: 
                   // FCB   $E8                     ; 1B0F: 
                   // FCB   $02                     ; 1B10: 
                   // FCB   $00                     ; 1B11: 
                   // FCB   $18                     ; 1B12: 
                   // FCB   $02                     ; 1B13: 
                   // FCB   $F3                     ; 1B14: 
                   // FCB   $34                     ; 1B15: 
                   // FCB   $00                     ; 1B16: 
                   // FCB   $68                     ; 1B17: 
                   // FCB   $81                     ; 1B18: 
                   // FCB   $02                     ; 1B19: 
                   // FCB   $00                     ; 1B1A: 
                   // FCB   $7F                     ; 1B1B: 
                   // FCB   $01                     ; 1B1C: 
                   // FCB   $FF                     ; 1B1D: 
                   // FCB   $72                     ; 1B1E: 
                   // FCB   $CC                     ; 1B1F: 
                   // FCB   $00                     ; 1B20: 
                   // FCB   $00                     ; 1B21: 
                   // FCB   $68                     ; 1B22: 
                   // FCB   $FF                     ; 1B23: 
                   // FCB   $8E                     ; 1B24: 
                   // FCB   $CC                     ; 1B25: 
                   // FCB   $01                     ; 1B26: 
                   // FCB   $04                     ; 1B27: 
                   // FCB   $60                     ; 1B28: 
                   // FCB   $38                     ; 1B29: 
                   // FCB   $BA                     ; 1B2A: 
                   // FCB   $10                     ; 1B2B: 
                   // FCB   $00                     ; 1B2C: 
                   // FCB   $00                     ; 1B2D: 
                   // FCB   $10                     ; 1B2E: 
                   // FCB   $BA                     ; 1B2F: 
                   // FCB   $38                     ; 1B30: 
                   // FCB   $04                     ; 1B31: 
                   // FCB   $50                     ; 1B32: 
                   // FCB   $08                     ; 1B33: 
                   // FCB   $00                     ; 1B34: 
                   // FCB   $F0                     ; 1B35: 
                   // FCB   $00                     ; 1B36: 
                   // FCB   $08                     ; 1B37: 
                   // FCB   $08                     ; 1B38: 
                   // FCB   $00                     ; 1B39: 
                   // FCB   $F0                     ; 1B3A: 
                   // FCB   $07                     ; 1B3B: 
                   // FCB   $5C                     ; 1B3C: 
                   // FCB   $7F                     ; 1B3D: 
                   // FCB   $00                     ; 1B3E: 
                   // FCB   $08                     ; 1B3F: 
                   // FCB   $00                     ; 1B40: 
                   // FCB   $18                     ; 1B41: 
                   // FCB   $00                     ; 1B42: 
                   // FCB   $E8                     ; 1B43: 
                   // FCB   $05                     ; 1B44: 
                   // FCB   $00                     ; 1B45: 
                   // FCB   $F6                     ; 1B46: 
                   // FCB   $18                     ; 1B47: 
                   // FCB   $05                     ; 1B48: 
                   // FCB   $10                     ; 1B49: 
                   // FCB   $00                     ; 1B4A: 
                   // FCB   $03                     ; 1B4B: 
                   // FCB   $40                     ; 1B4C: 
                   // FCB   $10                     ; 1B4D: 
                   // FCB   $00                     ; 1B4E: 
                   // FCB   $00                     ; 1B4F: 
                   // FCB   $7F                     ; 1B50: 
                   // FCB   $F0                     ; 1B51: 
                   // FCB   $00                     ; 1B52: 
                   // FCB   $00                     ; 1B53: 
                   // FCB   $81                     ; 1B54: 
                   // FCB   $00                     ; 1B55: 
                   // FCB   $7F                     ; 1B56: 
                   // FCB   $02                     ; 1B57: 
                   // FCB   $40                     ; 1B58: 
                   // FCB   $00                     ; 1B59: 
                   // FCB   $FC                     ; 1B5A: 
                   // FCB   $08                     ; 1B5B: 
                   // FCB   $04                     ; 1B5C: 
                   // FCB   $F8                     ; 1B5D: 
                   // FCB   $04                     ; 1B5E: 
                   // FCB   $06                     ; 1B5F: 
                   // FCB   $D6                     ; 1B60: 
                   // FCB   $C0                     ; 1B61: 
                   // FCB   $0D                     ; 1B62: 
                   // FCB   $34                     ; 1B63: 
                   // FCB   $00                     ; 1B64: 
                   // FCB   $18                     ; 1B65: 
                   // FCB   $F3                     ; 1B66: 
                   // FCB   $34                     ; 1B67: 
                   // FCB   $68                     ; 1B68: 
                   // FCB   $00                     ; 1B69: 
                   // FCB   $00                     ; 1B6A: 
                   // FCB   $80                     ; 1B6B: 
                   // FCB   $98                     ; 1B6C: 
                   // FCB   $00                     ; 1B6D: 
                   // FCB   $16                     ; 1B6E: 
                   // FCB   $58                     ; 1B6F: 
                   // FCB   $07                     ; 1B70: 
                   // FCB   $00                     ; 1B71: 
                   // FCB   $02                     ; 1B72: 
                   // FCB   $FE                     ; 1B73: 
                   // FCB   $02                     ; 1B74: 
                   // FCB   $FE                     ; 1B75: 
                   // FCB   $00                     ; 1B76: 
                   // FCB   $FE                     ; 1B77: 
                   // FCB   $FE                     ; 1B78: 
                   // FCB   $00                     ; 1B79: 
                   // FCB   $FE                     ; 1B7A: 
                   // FCB   $02                     ; 1B7B: 
                   // FCB   $FE                     ; 1B7C: 
                   // FCB   $02                     ; 1B7D: 
                   // FCB   $00                     ; 1B7E: 
                   // FCB   $02                     ; 1B7F: 
                   // FCB   $02                     ; 1B80: 
                   // FCB   $15                     ; 1B81: 
                   // FCB   $4C                     ; 1B82: 
                   // FCB   $07                     ; 1B83: 
                   // FCB   $7E                     ; 1B84: 
                   // FCB   $20                     ; 1B85: 
                   // FCB   $00                     ; 1B86: 
                   // FCB   $F0                     ; 1B87: 
                   // FCB   $60                     ; 1B88: 
                   // FCB   $E0                     ; 1B89: 
                   // FCB   $00                     ; 1B8A: 
                   // FCB   $F0                     ; 1B8B: 
                   // FCB   $A0                     ; 1B8C: 
                   // FCB   $10                     ; 1B8D: 
                   // FCB   $A0                     ; 1B8E: 
                   // FCB   $20                     ; 1B8F: 
                   // FCB   $00                     ; 1B90: 
                   // FCB   $10                     ; 1B91: 
                   // FCB   $60                     ; 1B92: 
                   // FCB   $06                     ; 1B93: 
                   // FCB   $DC                     ; 1B94: 
                   // FCB   $10                     ; 1B95: 
                   // FCB   $F8                     ; 1B96: 
                   // FCB   $FD                     ; 1B97: 
                   // FCB   $08                     ; 1B98: 
                   // FCB   $03                     ; 1B99: 
                   // FCB   $F8                     ; 1B9A: 
                   // FCB   $FA                     ; 1B9B: 
                   // FCB   $D8                     ; 1B9C: 
                   // FCB   $F3                     ; 1B9D: 
                   // FCB   $04                     ; 1B9E: 
                   // FCB   $E7                     ; 1B9F: 
                   // FCB   $20                     ; 1BA0: 
                   // FCB   $06                     ; 1BA1: 
                   // FCB   $EC                     ; 1BA2: 
                   // FCB   $E7                     ; 1BA3: 
                   // FCB   $00                     ; 1BA4: 
                   // FCB   $FE                     ; 1BA5: 
                   // FCB   $F4                     ; 1BA6: 
                   // FCB   $25                     ; 1BA7: 
                   // FCB   $DC                     ; 1BA8: 
                   // FCB   $DB                     ; 1BA9: 
                   // FCB   $24                     ; 1BAA: 
                   // FCB   $FF                     ; 1BAB: 
                   // FCB   $00                     ; 1BAC: 
                   // FCB   $FE                     ; 1BAD: 
                   // FCB   $0C                     ; 1BAE: 
                   // FCB   $03                     ; 1BAF: 
                   // FCB   $60                     ; 1BB0: 
                   // FCB   $04                     ; 1BB1: 
                   // FCB   $00                     ; 1BB2: 
                   // FCB   $FE                     ; 1BB3: 
                   // FCB   $0C                     ; 1BB4: 
                   // FCB   $FE                     ; 1BB5: 
                   // FCB   $00                     ; 1BB6: 
                   // FCB   $01                     ; 1BB7: 
                   // FCB   $80                     ; 1BB8: 
                   // FCB   $20                     ; 1BB9: 
                   // FCB   $00                     ; 1BBA: 
                   // FCB   $02                     ; 1BBB: 
                   // FCB   $40                     ; 1BBC: 
                   // FCB   $1E                     ; 1BBD: 
                   // FCB   $0C                     ; 1BBE: 
                   // FCB   $E2                     ; 1BBF: 
                   // FCB   $00                     ; 1BC0: 
                   // FCB   $04                     ; 1BC1: 
                   // FCB   $50                     ; 1BC2: 
                   // FCB   $1C                     ; 1BC3: 
                   // FCB   $18                     ; 1BC4: 
                   // FCB   $E4                     ; 1BC5: 
                   // FCB   $00                     ; 1BC6: 
                   // FCB   $04                     ; 1BC7: 
                   // FCB   $00                     ; 1BC8: 
                   // FCB   $FE                     ; 1BC9: 
                   // FCB   $F4                     ; 1BCA: 
                   // FCB   $04                     ; 1BCB: 
                   // FCB   $50                     ; 1BCC: 
                   // FCB   $1A                     ; 1BCD: 
                   // FCB   $24                     ; 1BCE: 
                   // FCB   $E6                     ; 1BCF: 
                   // FCB   $00                     ; 1BD0: 
                   // FCB   $06                     ; 1BD1: 
                   // FCB   $00                     ; 1BD2: 
                   // FCB   $FC                     ; 1BD3: 
                   // FCB   $E8                     ; 1BD4: 
                   // FCB   $04                     ; 1BD5: 
                   // FCB   $50                     ; 1BD6: 
                   // FCB   $18                     ; 1BD7: 
                   // FCB   $30                     ; 1BD8: 
                   // FCB   $E8                     ; 1BD9: 
                   // FCB   $00                     ; 1BDA: 
                   // FCB   $08                     ; 1BDB: 
                   // FCB   $00                     ; 1BDC: 
                   // FCB   $FA                     ; 1BDD: 
                   // FCB   $DC                     ; 1BDE: 
                   // FCB   $04                     ; 1BDF: 
                   // FCB   $50                     ; 1BE0: 
                   // FCB   $16                     ; 1BE1: 
                   // FCB   $3C                     ; 1BE2: 
                   // FCB   $EA                     ; 1BE3: 
                   // FCB   $00                     ; 1BE4: 
                   // FCB   $0A                     ; 1BE5: 
                   // FCB   $00                     ; 1BE6: 
                   // FCB   $F8                     ; 1BE7: 
                   // FCB   $D0                     ; 1BE8: 
                   // FCB   $04                     ; 1BE9: 
                   // FCB   $50                     ; 1BEA: 
                   // FCB   $14                     ; 1BEB: 
                   // FCB   $48                     ; 1BEC: 
                   // FCB   $EC                     ; 1BED: 
                   // FCB   $00                     ; 1BEE: 
                   // FCB   $0C                     ; 1BEF: 
                   // FCB   $00                     ; 1BF0: 
                   // FCB   $F6                     ; 1BF1: 
                   // FCB   $C4                     ; 1BF2: 
                   // FCB   $04                     ; 1BF3: 
                   // FCB   $50                     ; 1BF4: 
                   // FCB   $12                     ; 1BF5: 
                   // FCB   $54                     ; 1BF6: 
                   // FCB   $EE                     ; 1BF7: 
                   // FCB   $00                     ; 1BF8: 
                   // FCB   $0E                     ; 1BF9: 
                   // FCB   $00                     ; 1BFA: 
                   // FCB   $F4                     ; 1BFB: 
                   // FCB   $B8                     ; 1BFC: 
                   // FCB   $14                     ; 1BFD: 
                   // FCB   $4C                     ; 1BFE: 
                   // FCB   $14                     ; 1BFF: 
                   // FCB   $EA                     ; 1C00: 
                   // FCB   $0D                     ; 1C01: 
                   // FCB   $7F                     ; 1C02: 
                   // FCB   $E6                     ; 1C03: 
                   // FCB   $00                     ; 1C04: 
                   // FCB   $0B                     ; 1C05: 
                   // FCB   $02                     ; 1C06: 
                   // FCB   $0D                     ; 1C07: 
                   // FCB   $0D                     ; 1C08: 
                   // FCB   $02                     ; 1C09: 
                   // FCB   $0B                     ; 1C0A: 
                   // FCB   $02                     ; 1C0B: 
                   // FCB   $F5                     ; 1C0C: 
                   // FCB   $0D                     ; 1C0D: 
                   // FCB   $F3                     ; 1C0E: 
                   // FCB   $0B                     ; 1C0F: 
                   // FCB   $FE                     ; 1C10: 
                   // FCB   $F5                     ; 1C11: 
                   // FCB   $FE                     ; 1C12: 
                   // FCB   $F8                     ; 1C13: 
                   // FCB   $F3                     ; 1C14: 
                   // FCB   $F3                     ; 1C15: 
                   // FCB   $FE                     ; 1C16: 
                   // FCB   $F5                     ; 1C17: 
                   // FCB   $FE                     ; 1C18: 
                   // FCB   $0B                     ; 1C19: 
                   // FCB   $F3                     ; 1C1A: 
                   // FCB   $0D                     ; 1C1B: 
                   // FCB   $F5                     ; 1C1C: 
                   // FCB   $02                     ; 1C1D: 
                   // FCB   $01                     ; 1C1E: 
                   // FCB   $00                     ; 1C1F: 
                   // FCB   $F3                     ; 1C20: 
                   // FCB   $00                     ; 1C21: 
                   // FCB   $00                     ; 1C22: 
                   // FCB   $04                     ; 1C23: 
                   // FCB   $09                     ; 1C24: 
                   // FCB   $0D                     ; 1C25: 
                   // FCB   $11                     ; 1C26: 
                   // FCB   $15                     ; 1C27: 
                   // FCB   $18                     ; 1C28: 
                   // FCB   $18                     ; 1C29: 
                   // FCB   $18                     ; 1C2A: 
                   // FCB   $18                     ; 1C2B: 
                   // FCB   $15                     ; 1C2C: 
                   // FCB   $11                     ; 1C2D: 
                   // FCB   $0D                     ; 1C2E: 
                   // FCB   $09                     ; 1C2F: 
                   // FCB   $04                     ; 1C30: 
                   // FCB   $00                     ; 1C31: 
                   // FCB   $C8                     ; 1C32: 
                   // FCB   $3F                     ; 1C33: 
                   // FCB   $3F                     ; 1C34: 
                   // FCB   $00                     ; 1C35: 
                   // FCB   $20                     ; 1C36: 
                   // FCB   $C1                     ; 1C37: 
                   // FCB   $10                     ; 1C38: 
                   // FCB   $1E                     ; 1C39: 
                   // FCB   $3E                     ; 1C3A: 
                   // FCB   $3E                     ; 1C3B: 
                   // FCB   $00                     ; 1C3C: 
                   // FCB   $C1                     ; 1C3D: 
                   // FCB   $C1                     ; 1C3E: 
                   // FCB   $C1                     ; 1C3F: 
                   // FCB   $C1                     ; 1C40: 
                   // FCB   $20                     ; 1C41: 
                   // FCB   $3F                     ; 1C42: 
                   // FCB   $08                     ; 1C43: 
                   // FCB   $F8                     ; 1C44: 
                   // FCB   $30                     ; 1C45: 
                   // FCB   $C1                     ; 1C46: 
                   // FCB   $12                     ; 1C47: 
                   // FCB   $D0                     ; 1C48: 
                   // FCB   $C1                     ; 1C49: 
                   // FCB   $C1                     ; 1C4A: 
                   // FCB   $C1                     ; 1C4B: 
                   // FCB   $00                     ; 1C4C: 
                   // FCB   $3E                     ; 1C4D: 
                   // FCB   $3E                     ; 1C4E: 
                   // FCB   $3F                     ; 1C4F: 
                   // FCB   $20                     ; 1C50: 
                   // FCB   $C1                     ; 1C51: 
                   // FCB   $11                     ; 1C52: 
                   // FCB   $D0                     ; 1C53: 
                   // FCB   $16                     ; 1C54: 
                   // FCB   $94                     ; 1C55: 
                   // FCB   $08                     ; 1C56: 
                   // FCB   $7F                     ; 1C57: 
                   // FCB   $09                     ; 1C58: 
                   // FCB   $E2                     ; 1C59: 
                   // FCB   $0F                     ; 1C5A: 
                   // FCB   $1E                     ; 1C5B: 
                   // FCB   $E8                     ; 1C5C: 
                   // FCB   $0C                     ; 1C5D: 
                   // FCB   $00                     ; 1C5E: 
                   // FCB   $12                     ; 1C5F: 
                   // FCB   $EB                     ; 1C60: 
                   // FCB   $E2                     ; 1C61: 
                   // FCB   $09                     ; 1C62: 
                   // FCB   $F1                     ; 1C63: 
                   // FCB   $0C                     ; 1C64: 
                   // FCB   $06                     ; 1C65: 
                   // FCB   $09                     ; 1C66: 
                   // FCB   $EB                     ; 1C67: 
                   // FCB   $08                     ; 1C68: 
                   // FCB   $7F                     ; 1C69: 
                   // FCB   $09                     ; 1C6A: 
                   // FCB   $E5                     ; 1C6B: 
                   // FCB   $15                     ; 1C6C: 
                   // FCB   $1E                     ; 1C6D: 
                   // FCB   $00                     ; 1C6E: 
                   // FCB   $1E                     ; 1C6F: 
                   // FCB   $EB                     ; 1C70: 
                   // FCB   $EE                     ; 1C71: 
                   // FCB   $EE                     ; 1C72: 
                   // FCB   $0C                     ; 1C73: 
                   // FCB   $F4                     ; 1C74: 
                   // FCB   $EE                     ; 1C75: 
                   // FCB   $00                     ; 1C76: 
                   // FCB   $DC                     ; 1C77: 
                   // FCB   $1E                     ; 1C78: 
                   // FCB   $00                     ; 1C79: 
                   // FCB   $11                     ; 1C7A: 
                   // FCB   $D0                     ; 1C7B: 
                   // FCB   $0B                     ; 1C7C: 
                   // FCB   $92                     ; 1C7D: 
                   // FCB   $09                     ; 1C7E: 
                   // FCB   $7F                     ; 1C7F: 
                   // FCB   $04                     ; 1C80: 
                   // FCB   $00                     ; 1C81: 
                   // FCB   $FD                     ; 1C82: 
                   // FCB   $FF                     ; 1C83: 
                   // FCB   $FF                     ; 1C84: 
                   // FCB   $FD                     ; 1C85: 
                   // FCB   $FF                     ; 1C86: 
                   // FCB   $03                     ; 1C87: 
                   // FCB   $FD                     ; 1C88: 
                   // FCB   $01                     ; 1C89: 
                   // FCB   $03                     ; 1C8A: 
                   // FCB   $01                     ; 1C8B: 
                   // FCB   $01                     ; 1C8C: 
                   // FCB   $03                     ; 1C8D: 
                   // FCB   $01                     ; 1C8E: 
                   // FCB   $FD                     ; 1C8F: 
                   // FCB   $80                     ; 1C90: 
                   // FCB   $03                     ; 1C91: 
                   // FCB   $FF                     ; 1C92: 
                   // FCB   $02                     ; 1C93: 
                   // FCB   $FE                     ; 1C94: 
                   // FCB   $02                     ; 1C95: 
                   // FCB   $02                     ; 1C96: 
                   // FCB   $FE                     ; 1C97: 
                   // FCB   $FE                     ; 1C98: 
                   // FCB   $FE                     ; 1C99: 
                   // FCB   $02                     ; 1C9A: 
                   // FCB   $11                     ; 1C9B: 
                   // FCB   $D0                     ; 1C9C: 
                   // FCB   $16                     ; 1C9D: 
                   // FCB   $9E                     ; 1C9E: 
                   // FCB   $0D                     ; 1C9F: 
                   // FCB   $FD                     ; 1CA0: 
                   // FCB   $02                     ; 1CA1: 
                   // FCB   $04                     ; 1CA2: 
                   // FCB   $FE                     ; 1CA3: 
                   // FCB   $04                     ; 1CA4: 
                   // FCB   $FC                     ; 1CA5: 
                   // FCB   $00                     ; 1CA6: 
                   // FCB   $FE                     ; 1CA7: 
                   // FCB   $FC                     ; 1CA8: 
                   // FCB   $02                     ; 1CA9: 
                   // FCB   $FC                     ; 1CAA: 
                   // FCB   $04                     ; 1CAB: 
                   // FCB   $00                     ; 1CAC: 
                   // FCB   $FB                     ; 1CAD: 
                   // FCB   $02                     ; 1CAE: 
                   // FCB   $FE                     ; 1CAF: 
                   // FCB   $00                     ; 1CB0: 
                   // FCB   $E8                     ; 1CB1: 
                   // FCB   $F6                     ; 1CB2: 
                   // FCB   $0B                     ; 1CB3: 
                   // FCB   $0E                     ; 1CB4: 
                   // FCB   $FD                     ; 1CB5: 
                   // FCB   $01                     ; 1CB6: 
                   // FCB   $FE                     ; 1CB7: 
                   // FCB   $FD                     ; 1CB8: 
                   // FCB   $FE                     ; 1CB9: 
                   // FCB   $F4                     ; 1CBA: 
                   // FCB   $07                     ; 1CBB: 
                   // FCB   $11                     ; 1CBC: 
                   // FCB   $D0                     ; 1CBD: 
                   // FCB   $16                     ; 1CBE: 
                   // FCB   $6B                     ; 1CBF: 
                   // FCB   $1C                     ; 1CC0: 
                   // FCB   $D2                     ; 1CC1: 
                   // FCB   $1C                     ; 1CC2: 
                   // FCB   $E9                     ; 1CC3: 
                   // FCB   $1D                     ; 1CC4: 
                   // FCB   $08                     ; 1CC5: 
                   // FCB   $1D                     ; 1CC6: 
                   // FCB   $2B                     ; 1CC7: 
                   // FCB   $1D                     ; 1CC8: 
                   // FCB   $4E                     ; 1CC9: 
                   // FCB   $1D                     ; 1CCA: 
                   // FCB   $6B                     ; 1CCB: 
                   // FCB   $1D                     ; 1CCC: 
                   // FCB   $93                     ; 1CCD: 
                   // FCB   $1D                     ; 1CCE: 
                   // FCB   $B6                     ; 1CCF: 
                   // FCB   $1D                     ; 1CD0: 
                   // FCB   $D9                     ; 1CD1: 
                   // FCB   $0A                     ; 1CD2: 
                   // FCB   $7D                     ; 1CD3: 
                   // FCB   $0A                     ; 1CD4: 
                   // FCB   $00                     ; 1CD5: 
                   // FCB   $FA                     ; 1CD6: 
                   // FCB   $F6                     ; 1CD7: 
                   // FCB   $E8                     ; 1CD8: 
                   // FCB   $0A                     ; 1CD9: 
                   // FCB   $1E                     ; 1CDA: 
                   // FCB   $00                     ; 1CDB: 
                   // FCB   $FA                     ; 1CDC: 
                   // FCB   $0A                     ; 1CDD: 
                   // FCB   $E8                     ; 1CDE: 
                   // FCB   $F6                     ; 1CDF: 
                   // FCB   $1B                     ; 1CE0: 
                   // FCB   $FB                     ; 1CE1: 
                   // FCB   $0D                     ; 1CE2: 
                   // FCB   $03                     ; 1CE3: 
                   // FCB   $C0                     ; 1CE4: 
                   // FCB   $00                     ; 1CE5: 
                   // FCB   $04                     ; 1CE6: 
                   // FCB   $F3                     ; 1CE7: 
                   // FCB   $03                     ; 1CE8: 
                   // FCB   $0E                     ; 1CE9: 
                   // FCB   $7E                     ; 1CEA: 
                   // FCB   $0A                     ; 1CEB: 
                   // FCB   $F0                     ; 1CEC: 
                   // FCB   $E2                     ; 1CED: 
                   // FCB   $0A                     ; 1CEE: 
                   // FCB   $0B                     ; 1CEF: 
                   // FCB   $16                     ; 1CF0: 
                   // FCB   $FC                     ; 1CF1: 
                   // FCB   $01                     ; 1CF2: 
                   // FCB   $0B                     ; 1CF3: 
                   // FCB   $00                     ; 1CF4: 
                   // FCB   $FC                     ; 1CF5: 
                   // FCB   $FF                     ; 1CF6: 
                   // FCB   $10                     ; 1CF7: 
                   // FCB   $E0                     ; 1CF8: 
                   // FCB   $FB                     ; 1CF9: 
                   // FCB   $0A                     ; 1CFA: 
                   // FCB   $F4                     ; 1CFB: 
                   // FCB   $0A                     ; 1CFC: 
                   // FCB   $01                     ; 1CFD: 
                   // FCB   $00                     ; 1CFE: 
                   // FCB   $05                     ; 1CFF: 
                   // FCB   $FD                     ; 1D00: 
                   // FCB   $04                     ; 1D01: 
                   // FCB   $F3                     ; 1D02: 
                   // FCB   $01                     ; 1D03: 
                   // FCB   $03                     ; 1D04: 
                   // FCB   $FC                     ; 1D05: 
                   // FCB   $0D                     ; 1D06: 
                   // FCB   $00                     ; 1D07: 
                   // FCB   $10                     ; 1D08: 
                   // FCB   $7F                     ; 1D09: 
                   // FCB   $0A                     ; 1D0A: 
                   // FCB   $E5                     ; 1D0B: 
                   // FCB   $E7                     ; 1D0C: 
                   // FCB   $0A                     ; 1D0D: 
                   // FCB   $0C                     ; 1D0E: 
                   // FCB   $28                     ; 1D0F: 
                   // FCB   $FC                     ; 1D10: 
                   // FCB   $01                     ; 1D11: 
                   // FCB   $00                     ; 1D12: 
                   // FCB   $01                     ; 1D13: 
                   // FCB   $0B                     ; 1D14: 
                   // FCB   $00                     ; 1D15: 
                   // FCB   $00                     ; 1D16: 
                   // FCB   $FF                     ; 1D17: 
                   // FCB   $FC                     ; 1D18: 
                   // FCB   $FF                     ; 1D19: 
                   // FCB   $BD                     ; 1D1A: 
                   // FCB   $0A                     ; 1D1B: 
                   // FCB   $CE                     ; 1D1C: 
                   // FCB   $FC                     ; 1D1D: 
                   // FCB   $14                     ; 1D1E: 
                   // FCB   $09                     ; 1D1F: 
                   // FCB   $02                     ; 1D20: 
                   // FCB   $00                     ; 1D21: 
                   // FCB   $02                     ; 1D22: 
                   // FCB   $FE                     ; 1D23: 
                   // FCB   $06                     ; 1D24: 
                   // FCB   $F6                     ; 1D25: 
                   // FCB   $03                     ; 1D26: 
                   // FCB   $02                     ; 1D27: 
                   // FCB   $F7                     ; 1D28: 
                   // FCB   $0A                     ; 1D29: 
                   // FCB   $00                     ; 1D2A: 
                   // FCB   $10                     ; 1D2B: 
                   // FCB   $7F                     ; 1D2C: 
                   // FCB   $07                     ; 1D2D: 
                   // FCB   $DA                     ; 1D2E: 
                   // FCB   $ED                     ; 1D2F: 
                   // FCB   $0A                     ; 1D30: 
                   // FCB   $05                     ; 1D31: 
                   // FCB   $3C                     ; 1D32: 
                   // FCB   $FD                     ; 1D33: 
                   // FCB   $04                     ; 1D34: 
                   // FCB   $00                     ; 1D35: 
                   // FCB   $02                     ; 1D36: 
                   // FCB   $0C                     ; 1D37: 
                   // FCB   $00                     ; 1D38: 
                   // FCB   $00                     ; 1D39: 
                   // FCB   $FE                     ; 1D3A: 
                   // FCB   $FC                     ; 1D3B: 
                   // FCB   $FC                     ; 1D3C: 
                   // FCB   $BD                     ; 1D3D: 
                   // FCB   $09                     ; 1D3E: 
                   // FCB   $BA                     ; 1D3F: 
                   // FCB   $FD                     ; 1D40: 
                   // FCB   $1B                     ; 1D41: 
                   // FCB   $0A                     ; 1D42: 
                   // FCB   $02                     ; 1D43: 
                   // FCB   $00                     ; 1D44: 
                   // FCB   $01                     ; 1D45: 
                   // FCB   $FF                     ; 1D46: 
                   // FCB   $08                     ; 1D47: 
                   // FCB   $F4                     ; 1D48: 
                   // FCB   $09                     ; 1D49: 
                   // FCB   $02                     ; 1D4A: 
                   // FCB   $EE                     ; 1D4B: 
                   // FCB   $0B                     ; 1D4C: 
                   // FCB   $01                     ; 1D4D: 
                   // FCB   $0D                     ; 1D4E: 
                   // FCB   $7F                     ; 1D4F: 
                   // FCB   $00                     ; 1D50: 
                   // FCB   $D0                     ; 1D51: 
                   // FCB   $F3                     ; 1D52: 
                   // FCB   $0A                     ; 1D53: 
                   // FCB   $05                     ; 1D54: 
                   // FCB   $4C                     ; 1D55: 
                   // FCB   $FB                     ; 1D56: 
                   // FCB   $06                     ; 1D57: 
                   // FCB   $00                     ; 1D58: 
                   // FCB   $04                     ; 1D59: 
                   // FCB   $0F                     ; 1D5A: 
                   // FCB   $00                     ; 1D5B: 
                   // FCB   $00                     ; 1D5C: 
                   // FCB   $FC                     ; 1D5D: 
                   // FCB   $FB                     ; 1D5E: 
                   // FCB   $FA                     ; 1D5F: 
                   // FCB   $B8                     ; 1D60: 
                   // FCB   $03                     ; 1D61: 
                   // FCB   $AA                     ; 1D62: 
                   // FCB   $FF                     ; 1D63: 
                   // FCB   $1C                     ; 1D64: 
                   // FCB   $0C                     ; 1D65: 
                   // FCB   $02                     ; 1D66: 
                   // FCB   $00                     ; 1D67: 
                   // FCB   $0A                     ; 1D68: 
                   // FCB   $F3                     ; 1D69: 
                   // FCB   $0E                     ; 1D6A: 
                   // FCB   $12                     ; 1D6B: 
                   // FCB   $7F                     ; 1D6C: 
                   // FCB   $04                     ; 1D6D: 
                   // FCB   $EA                     ; 1D6E: 
                   // FCB   $F8                     ; 1D6F: 
                   // FCB   $05                     ; 1D70: 
                   // FCB   $FC                     ; 1D71: 
                   // FCB   $25                     ; 1D72: 
                   // FCB   $04                     ; 1D73: 
                   // FCB   $0A                     ; 1D74: 
                   // FCB   $F9                     ; 1D75: 
                   // FCB   $04                     ; 1D76: 
                   // FCB   $FF                     ; 1D77: 
                   // FCB   $02                     ; 1D78: 
                   // FCB   $1B                     ; 1D79: 
                   // FCB   $00                     ; 1D7A: 
                   // FCB   $FE                     ; 1D7B: 
                   // FCB   $FE                     ; 1D7C: 
                   // FCB   $EF                     ; 1D7D: 
                   // FCB   $F8                     ; 1D7E: 
                   // FCB   $FD                     ; 1D7F: 
                   // FCB   $01                     ; 1D80: 
                   // FCB   $F8                     ; 1D81: 
                   // FCB   $FE                     ; 1D82: 
                   // FCB   $D3                     ; 1D83: 
                   // FCB   $01                     ; 1D84: 
                   // FCB   $10                     ; 1D85: 
                   // FCB   $09                     ; 1D86: 
                   // FCB   $01                     ; 1D87: 
                   // FCB   $01                     ; 1D88: 
                   // FCB   $06                     ; 1D89: 
                   // FCB   $00                     ; 1D8A: 
                   // FCB   $02                     ; 1D8B: 
                   // FCB   $F6                     ; 1D8C: 
                   // FCB   $07                     ; 1D8D: 
                   // FCB   $40                     ; 1D8E: 
                   // FCB   $00                     ; 1D8F: 
                   // FCB   $FE                     ; 1D90: 
                   // FCB   $0A                     ; 1D91: 
                   // FCB   $F9                     ; 1D92: 
                   // FCB   $10                     ; 1D93: 
                   // FCB   $7F                     ; 1D94: 
                   // FCB   $FF                     ; 1D95: 
                   // FCB   $EE                     ; 1D96: 
                   // FCB   $FC                     ; 1D97: 
                   // FCB   $04                     ; 1D98: 
                   // FCB   $FA                     ; 1D99: 
                   // FCB   $1B                     ; 1D9A: 
                   // FCB   $07                     ; 1D9B: 
                   // FCB   $08                     ; 1D9C: 
                   // FCB   $F4                     ; 1D9D: 
                   // FCB   $06                     ; 1D9E: 
                   // FCB   $21                     ; 1D9F: 
                   // FCB   $00                     ; 1DA0: 
                   // FCB   $F3                     ; 1DA1: 
                   // FCB   $FA                     ; 1DA2: 
                   // FCB   $03                     ; 1DA3: 
                   // FCB   $F6                     ; 1DA4: 
                   // FCB   $BD                     ; 1DA5: 
                   // FCB   $F8                     ; 1DA6: 
                   // FCB   $E3                     ; 1DA7: 
                   // FCB   $03                     ; 1DA8: 
                   // FCB   $09                     ; 1DA9: 
                   // FCB   $08                     ; 1DAA: 
                   // FCB   $00                     ; 1DAB: 
                   // FCB   $02                     ; 1DAC: 
                   // FCB   $04                     ; 1DAD: 
                   // FCB   $00                     ; 1DAE: 
                   // FCB   $02                     ; 1DAF: 
                   // FCB   $F9                     ; 1DB0: 
                   // FCB   $08                     ; 1DB1: 
                   // FCB   $FF                     ; 1DB2: 
                   // FCB   $FD                     ; 1DB3: 
                   // FCB   $07                     ; 1DB4: 
                   // FCB   $F9                     ; 1DB5: 
                   // FCB   $10                     ; 1DB6: 
                   // FCB   $7F                     ; 1DB7: 
                   // FCB   $01                     ; 1DB8: 
                   // FCB   $F3                     ; 1DB9: 
                   // FCB   $FB                     ; 1DBA: 
                   // FCB   $03                     ; 1DBB: 
                   // FCB   $F8                     ; 1DBC: 
                   // FCB   $19                     ; 1DBD: 
                   // FCB   $08                     ; 1DBE: 
                   // FCB   $03                     ; 1DBF: 
                   // FCB   $F1                     ; 1DC0: 
                   // FCB   $03                     ; 1DC1: 
                   // FCB   $28                     ; 1DC2: 
                   // FCB   $00                     ; 1DC3: 
                   // FCB   $EF                     ; 1DC4: 
                   // FCB   $FD                     ; 1DC5: 
                   // FCB   $06                     ; 1DC6: 
                   // FCB   $FB                     ; 1DC7: 
                   // FCB   $BD                     ; 1DC8: 
                   // FCB   $F7                     ; 1DC9: 
                   // FCB   $E6                     ; 1DCA: 
                   // FCB   $02                     ; 1DCB: 
                   // FCB   $06                     ; 1DCC: 
                   // FCB   $08                     ; 1DCD: 
                   // FCB   $00                     ; 1DCE: 
                   // FCB   $02                     ; 1DCF: 
                   // FCB   $03                     ; 1DD0: 
                   // FCB   $00                     ; 1DD1: 
                   // FCB   $02                     ; 1DD2: 
                   // FCB   $F9                     ; 1DD3: 
                   // FCB   $04                     ; 1DD4: 
                   // FCB   $FF                     ; 1DD5: 
                   // FCB   $FF                     ; 1DD6: 
                   // FCB   $08                     ; 1DD7: 
                   // FCB   $FC                     ; 1DD8: 
                   // FCB   $0F                     ; 1DD9: 
                   // FCB   $6D                     ; 1DDA: 
                   // FCB   $F2                     ; 1DDB: 
                   // FCB   $FF                     ; 1DDC: 
                   // FCB   $12                     ; 1DDD: 
                   // FCB   $F7                     ; 1DDE: 
                   // FCB   $05                     ; 1DDF: 
                   // FCB   $09                     ; 1DE0: 
                   // FCB   $00                     ; 1DE1: 
                   // FCB   $02                     ; 1DE2: 
                   // FCB   $FB                     ; 1DE3: 
                   // FCB   $09                     ; 1DE4: 
                   // FCB   $EE                     ; 1DE5: 
                   // FCB   $F7                     ; 1DE6: 
                   // FCB   $F8                     ; 1DE7: 
                   // FCB   $FF                     ; 1DE8: 
                   // FCB   $17                     ; 1DE9: 
                   // FCB   $FE                     ; 1DEA: 
                   // FCB   $EE                     ; 1DEB: 
                   // FCB   $16                     ; 1DEC: 
                   // FCB   $02                     ; 1DED: 
                   // FCB   $EA                     ; 1DEE: 
                   // FCB   $02                     ; 1DEF: 
                   // FCB   $E9                     ; 1DF0: 
                   // FCB   $FE                     ; 1DF1: 
                   // FCB   $1E                     ; 1DF2: 
                   // FCB   $FC                     ; 1DF3: 
                   // FCB   $0D                     ; 1DF4: 
                   // FCB   $02                     ; 1DF5: 
                   // FCB   $00                     ; 1DF6: 
                   // FCB   $04                     ; 1DF7: 
                   // FCB   $F3                     ; 1DF8: 
                   // FCB   $02                     ; 1DF9: 
                   // FCB   $0E                     ; 1DFA: 
                   // FCB   $55                     ; 1DFB: 
                   // FCB   $F0                     ; 1DFC: 
                   // FCB   $F0                     ; 1DFD: 
                   // FCB   $E8                     ; 1DFE: 
                   // FCB   $E8                     ; 1DFF: 
                   // FCB   $38                     ; 1E00: 
                   // FCB   $F8                     ; 1E01: 
                   // FCB   $F8                     ; 1E02: 
                   // FCB   $18                     ; 1E03: 
                   // FCB   $18                     ; 1E04: 
                   // FCB   $0C                     ; 1E05: 
                   // FCB   $20                     ; 1E06: 
                   // FCB   $F4                     ; 1E07: 
                   // FCB   $10                     ; 1E08: 
                   // FCB   $2C                     ; 1E09: 
                   // FCB   $E0                     ; 1E0A: 
                   // FCB   $F8                     ; 1E0B: 
                   // FCB   $54                     ; 1E0C: 
                   // FCB   $E8                     ; 1E0D: 
                   // FCB   $20                     ; 1E0E: 
                   // FCB   $0C                     ; 1E0F: 
                   // FCB   $14                     ; 1E10: 
                   // FCB   $C8                     ; 1E11: 
                   // FCB   $DC                     ; 1E12: 
                   // FCB   $EC                     ; 1E13: 
                   // FCB   $1C                     ; 1E14: 
                   // FCB   $E4                     ; 1E15: 
                   // FCB   $D4                     ; 1E16: 
                   // FCB   $24                     ; 1E17: 
                   // FCB   $F8                     ; 1E18: 
                   // FCB   $12                     ; 1E19: 
                   // FCB   $55                     ; 1E1A: 
                   // FCB   $C0                     ; 1E1B: 
                   // FCB   $E8                     ; 1E1C: 
                   // FCB   $E0                     ; 1E1D: 
                   // FCB   $F4                     ; 1E1E: 
                   // FCB   $4C                     ; 1E1F: 
                   // FCB   $C0                     ; 1E20: 
                   // FCB   $08                     ; 1E21: 
                   // FCB   $20                     ; 1E22: 
                   // FCB   $2C                     ; 1E23: 
                   // FCB   $F4                     ; 1E24: 
                   // FCB   $0C                     ; 1E25: 
                   // FCB   $E4                     ; 1E26: 
                   // FCB   $14                     ; 1E27: 
                   // FCB   $28                     ; 1E28: 
                   // FCB   $EC                     ; 1E29: 
                   // FCB   $14                     ; 1E2A: 
                   // FCB   $55                     ; 1E2B: 
                   // FCB   $1C                     ; 1E2C: 
                   // FCB   $24                     ; 1E2D: 
                   // FCB   $20                     ; 1E2E: 
                   // FCB   $FC                     ; 1E2F: 
                   // FCB   $F8                     ; 1E30: 
                   // FCB   $48                     ; 1E31: 
                   // FCB   $E8                     ; 1E32: 
                   // FCB   $F0                     ; 1E33: 
                   // FCB   $C4                     ; 1E34: 
                   // FCB   $34                     ; 1E35: 
                   // FCB   $04                     ; 1E36: 
                   // FCB   $20                     ; 1E37: 
                   // FCB   $E4                     ; 1E38: 
                   // FCB   $C0                     ; 1E39: 
                   // FCB   $FC                     ; 1E3A: 
                   // FCB   $20                     ; 1E3B: 
                   // FCB   $40                     ; 1E3C: 
                   // FCB   $CC                     ; 1E3D: 
                   // FCB   $D0                     ; 1E3E: 
                   // FCB   $E8                     ; 1E3F: 
                   // FCB   $14                     ; 1E40: 
                   // FCB   $80                     ; 1E41: 
                   // FCB   $55                     ; 1E42: 
                   // FCB   $40                     ; 1E43: 
                   // FCB   $33                     ; 1E44: 
                   // FCB   $2C                     ; 1E45: 
                   // FCB   $25                     ; 1E46: 
                   // FCB   $20                     ; 1E47: 
                   // FCB   $1C                     ; 1E48: 
                   // FCB   $1A                     ; 1E49: 
                   // FCB   $17                     ; 1E4A: 
                   // FCB   $15                     ; 1E4B: 
                   // FCB   $14                     ; 1E4C: 
                   // FCB   $12                     ; 1E4D: 
                   // FCB   $11                     ; 1E4E: 
                   // FCB   $10                     ; 1E4F: 
                   // FCB   $F1                     ; 1E50: 
                   // FCB   $E4                     ; 1E51: 
                   // FCB   $D8                     ; 1E52: 
                   // FCB   $CD                     ; 1E53: 
                   // FCB   $C3                     ; 1E54: 
                   // FCB   $BA                     ; 1E55: 
                   // FCB   $B2                     ; 1E56: 
                   // FCB   $AB                     ; 1E57: 
                   // FCB   $A4                     ; 1E58: 
                   // FCB   $9E                     ; 1E59: 
                   // FCB   $98                     ; 1E5A: 
                   // FCB   $92                     ; 1E5B: 
                   // FCB   $8D                     ; 1E5C: 
                   // FCB   $89                     ; 1E5D: 
                   // FCB   $84                     ; 1E5E: 
                   // FCB   $80                     ; 1E5F: 
                   // FCB   $7C                     ; 1E60: 
                   // FCB   $78                     ; 1E61: 
                   // FCB   $75                     ; 1E62: 
                   // FCB   $72                     ; 1E63: 
                   // FCB   $6F                     ; 1E64: 
                   // FCB   $6C                     ; 1E65: 
                   // FCB   $69                     ; 1E66: 
                   // FCB   $66                     ; 1E67: 
                   // FCB   $64                     ; 1E68: 
                   // FCB   $62                     ; 1E69: 
                   // FCB   $5F                     ; 1E6A: 
                   // FCB   $5D                     ; 1E6B: 
                   // FCB   $5B                     ; 1E6C: 
                   // FCB   $59                     ; 1E6D: 
                   // FCB   $57                     ; 1E6E: 
                   // FCB   $55                     ; 1E6F: 
                   // FCB   $54                     ; 1E70: 
                   // FCB   $52                     ; 1E71: 
                   // FCB   $50                     ; 1E72: 
                   // FCB   $4F                     ; 1E73: 
                   // FCB   $4D                     ; 1E74: 
                   // FCB   $4C                     ; 1E75: 
                   // FCB   $4A                     ; 1E76: 
                   // FCB   $49                     ; 1E77: 
                   // FCB   $48                     ; 1E78: 
                   // FCB   $47                     ; 1E79: 
                   // FCB   $45                     ; 1E7A: 
                   // FCB   $44                     ; 1E7B: 
                   // FCB   $43                     ; 1E7C: 
                   // FCB   $42                     ; 1E7D: 
                   // FCB   $41                     ; 1E7E: 
                   // FCB   $40                     ; 1E7F: 
                   // FCB   $3F                     ; 1E80: 
                   // FCB   $3E                     ; 1E81: 
                   // FCB   $3D                     ; 1E82: 
                   // FCB   $3C                     ; 1E83: 
                   // FCB   $3B                     ; 1E84: 
                   // FCB   $3B                     ; 1E85: 
                   // FCB   $3A                     ; 1E86: 
                   // FCB   $39                     ; 1E87: 
                   // FCB   $38                     ; 1E88: 
                   // FCB   $37                     ; 1E89: 
                   // FCB   $37                     ; 1E8A: 
                   // FCB   $36                     ; 1E8B: 
                   // FCB   $35                     ; 1E8C: 
                   // FCB   $35                     ; 1E8D: 
                   // FCB   $34                     ; 1E8E: 
                   // FCB   $33                     ; 1E8F: 
                   // FCB   $33                     ; 1E90: 
                   // FCB   $32                     ; 1E91: 
                   // FCB   $31                     ; 1E92: 
                   // FCB   $31                     ; 1E93: 
                   // FCB   $30                     ; 1E94: 
                   // FCB   $30                     ; 1E95: 
                   // FCB   $2F                     ; 1E96: 
                   // FCB   $2F                     ; 1E97: 
                   // FCB   $2E                     ; 1E98: 
                   // FCB   $2E                     ; 1E99: 
                   // FCB   $2D                     ; 1E9A: 
                   // FCB   $2D                     ; 1E9B: 
                   // FCB   $2C                     ; 1E9C: 
                   // FCB   $2C                     ; 1E9D: 
                   // FCB   $2B                     ; 1E9E: 
                   // FCB   $2B                     ; 1E9F: 
                   // FCB   $2A                     ; 1EA0: 
                   // FCB   $2A                     ; 1EA1: 
                   // FCB   $29                     ; 1EA2: 
                   // FCB   $29                     ; 1EA3: 
                   // FCB   $29                     ; 1EA4: 
                   // FCB   $28                     ; 1EA5: 
                   // FCB   $28                     ; 1EA6: 
                   // FCB   $27                     ; 1EA7: 
                   // FCB   $27                     ; 1EA8: 
                   // FCB   $27                     ; 1EA9: 
                   // FCB   $26                     ; 1EAA: 
                   // FCB   $26                     ; 1EAB: 
                   // FCB   $26                     ; 1EAC: 
                   // FCB   $25                     ; 1EAD: 
                   // FCB   $25                     ; 1EAE: 
                   // FCB   $25                     ; 1EAF: 
                   // FCB   $24                     ; 1EB0: 
                   // FCB   $24                     ; 1EB1: 
                   // FCB   $24                     ; 1EB2: 
                   // FCB   $23                     ; 1EB3: 
                   // FCB   $23                     ; 1EB4: 
                   // FCB   $23                     ; 1EB5: 
                   // FCB   $22                     ; 1EB6: 
                   // FCB   $22                     ; 1EB7: 
                   // FCB   $22                     ; 1EB8: 
                   // FCB   $22                     ; 1EB9: 
                   // FCB   $21                     ; 1EBA: 
                   // FCB   $21                     ; 1EBB: 
                   // FCB   $21                     ; 1EBC: 
                   // FCB   $21                     ; 1EBD: 
                   // FCB   $20                     ; 1EBE: 
                   // FCB   $0D                     ; 1EBF: 
                   // FCB   $10                     ; 1EC0: 
                   // FCB   $00                     ; 1EC1: 
                   // FCB   $00                     ; 1EC2: 
                   // FCB   $00                     ; 1EC3: 
                   // FCB   $00                     ; 1EC4: 
                   // FCB   $00                     ; 1EC5: 
                   // FCB   $00                     ; 1EC6: 
                   // FCB   $00                     ; 1EC7: 
                   // FCB   $00                     ; 1EC8: 
                   // FCB   $00                     ; 1EC9: 
                   // FCB   $7F                     ; 1ECA: 
                   // FCB   $F8                     ; 1ECB: 
                   // FCB   $00                     ; 1ECC: 
                   // FCB   $00                     ; 1ECD: 
                   // FCB   $00                     ; 1ECE: 
                   // FCB   $00                     ; 1ECF: 
                   // FCB   $00                     ; 1ED0: 
                   // FCB   $00                     ; 1ED1: 
                   // FCB   $00                     ; 1ED2: 
                   // FCB   $00                     ; 1ED3: 
                   // FCB   $00                     ; 1ED4: 
                   // FCB   $00                     ; 1ED5: 
                   // FCB   $0F                     ; 1ED6: 
                   // FCB   $C0                     ; 1ED7: 
                   // FCB   $0F                     ; 1ED8: 
                   // FCB   $C0                     ; 1ED9: 
                   // FCB   $00                     ; 1EDA: 
                   // FCB   $00                     ; 1EDB: 
                   // FCB   $00                     ; 1EDC: 
                   // FCB   $00                     ; 1EDD: 
                   // FCB   $00                     ; 1EDE: 
                   // FCB   $00                     ; 1EDF: 
                   // FCB   $00                     ; 1EE0: 
                   // FCB   $00                     ; 1EE1: 
                   // FCB   $00                     ; 1EE2: 
                   // FCB   $78                     ; 1EE3: 
                   // FCB   $00                     ; 1EE4: 
                   // FCB   $00                     ; 1EE5: 
                   // FCB   $78                     ; 1EE6: 
                   // FCB   $00                     ; 1EE7: 
                   // FCB   $00                     ; 1EE8: 
                   // FCB   $00                     ; 1EE9: 
                   // FCB   $00                     ; 1EEA: 
                   // FCB   $00                     ; 1EEB: 
                   // FCB   $00                     ; 1EEC: 
                   // FCB   $00                     ; 1EED: 
                   // FCB   $00                     ; 1EEE: 
                   // FCB   $01                     ; 1EEF: 
                   // FCB   $C0                     ; 1EF0: 
                   // FCB   $00                     ; 1EF1: 
                   // FCB   $00                     ; 1EF2: 
                   // FCB   $0F                     ; 1EF3: 
                   // FCB   $00                     ; 1EF4: 
                   // FCB   $00                     ; 1EF5: 
                   // FCB   $00                     ; 1EF6: 
                   // FCB   $00                     ; 1EF7: 
                   // FCB   $00                     ; 1EF8: 
                   // FCB   $00                     ; 1EF9: 
                   // FCB   $00                     ; 1EFA: 
                   // FCB   $00                     ; 1EFB: 
                   // FCB   $0F                     ; 1EFC: 
                   // FCB   $00                     ; 1EFD: 
                   // FCB   $00                     ; 1EFE: 
                   // FCB   $00                     ; 1EFF: 
                   // FCB   $01                     ; 1F00: 
                   // FCB   $C0                     ; 1F01: 
                   // FCB   $00                     ; 1F02: 
                   // FCB   $00                     ; 1F03: 
                   // FCB   $00                     ; 1F04: 
                   // FCB   $00                     ; 1F05: 
                   // FCB   $00                     ; 1F06: 
                   // FCB   $00                     ; 1F07: 
                   // FCB   $00                     ; 1F08: 
                   // FCB   $38                     ; 1F09: 
                   // FCB   $00                     ; 1F0A: 
                   // FCB   $00                     ; 1F0B: 
                   // FCB   $00                     ; 1F0C: 
                   // FCB   $00                     ; 1F0D: 
                   // FCB   $70                     ; 1F0E: 
                   // FCB   $00                     ; 1F0F: 
                   // FCB   $00                     ; 1F10: 
                   // FCB   $00                     ; 1F11: 
                   // FCB   $00                     ; 1F12: 
                   // FCB   $00                     ; 1F13: 
                   // FCB   $00                     ; 1F14: 
                   // FCB   $00                     ; 1F15: 
                   // FCB   $E0                     ; 1F16: 
                   // FCB   $00                     ; 1F17: 
                   // FCB   $00                     ; 1F18: 
                   // FCB   $00                     ; 1F19: 
                   // FCB   $00                     ; 1F1A: 
                   // FCB   $1C                     ; 1F1B: 
                   // FCB   $00                     ; 1F1C: 
                   // FCB   $80                     ; 1F1D: 
                   // FCB   $00                     ; 1F1E: 
                   // FCB   $00                     ; 1F1F: 
                   // FCB   $00                     ; 1F20: 
                   // FCB   $00                     ; 1F21: 
                   // FCB   $07                     ; 1F22: 
                   // FCB   $80                     ; 1F23: 
                   // FCB   $00                     ; 1F24: 
                   // FCB   $00                     ; 1F25: 
                   // FCB   $00                     ; 1F26: 
                   // FCB   $00                     ; 1F27: 
                   // FCB   $07                     ; 1F28: 
                   // FCB   $00                     ; 1F29: 
                   // FCB   $E0                     ; 1F2A: 
                   // FCB   $00                     ; 1F2B: 
                   // FCB   $00                     ; 1F2C: 
                   // FCB   $00                     ; 1F2D: 
                   // FCB   $00                     ; 1F2E: 
                   // FCB   $1C                     ; 1F2F: 
                   // FCB   $00                     ; 1F30: 
                   // FCB   $00                     ; 1F31: 
                   // FCB   $00                     ; 1F32: 
                   // FCB   $00                     ; 1F33: 
                   // FCB   $00                     ; 1F34: 
                   // FCB   $00                     ; 1F35: 
                   // FCB   $00                     ; 1F36: 
                   // FCB   $38                     ; 1F37: 
                   // FCB   $00                     ; 1F38: 
                   // FCB   $00                     ; 1F39: 
                   // FCB   $00                     ; 1F3A: 
                   // FCB   $00                     ; 1F3B: 
                   // FCB   $70                     ; 1F3C: 
                   // FCB   $00                     ; 1F3D: 
                   // FCB   $00                     ; 1F3E: 
                   // FCB   $00                     ; 1F3F: 
                   // FCB   $00                     ; 1F40: 
                   // FCB   $00                     ; 1F41: 
                   // FCB   $00                     ; 1F42: 
                   // FCB   $00                     ; 1F43: 
                   // FCB   $0F                     ; 1F44: 
                   // FCB   $00                     ; 1F45: 
                   // FCB   $00                     ; 1F46: 
                   // FCB   $00                     ; 1F47: 
                   // FCB   $01                     ; 1F48: 
                   // FCB   $C0                     ; 1F49: 
                   // FCB   $00                     ; 1F4A: 
                   // FCB   $00                     ; 1F4B: 
                   // FCB   $00                     ; 1F4C: 
                   // FCB   $00                     ; 1F4D: 
                   // FCB   $00                     ; 1F4E: 
                   // FCB   $00                     ; 1F4F: 
                   // FCB   $00                     ; 1F50: 
                   // FCB   $01                     ; 1F51: 
                   // FCB   $C0                     ; 1F52: 
                   // FCB   $00                     ; 1F53: 
                   // FCB   $00                     ; 1F54: 
                   // FCB   $0F                     ; 1F55: 
                   // FCB   $00                     ; 1F56: 
                   // FCB   $00                     ; 1F57: 
                   // FCB   $00                     ; 1F58: 
                   // FCB   $00                     ; 1F59: 
                   // FCB   $00                     ; 1F5A: 
                   // FCB   $00                     ; 1F5B: 
                   // FCB   $00                     ; 1F5C: 
                   // FCB   $00                     ; 1F5D: 
                   // FCB   $00                     ; 1F5E: 
                   // FCB   $78                     ; 1F5F: 
                   // FCB   $00                     ; 1F60: 
                   // FCB   $00                     ; 1F61: 
                   // FCB   $78                     ; 1F62: 
                   // FCB   $00                     ; 1F63: 
                   // FCB   $00                     ; 1F64: 
                   // FCB   $00                     ; 1F65: 
                   // FCB   $00                     ; 1F66: 
                   // FCB   $00                     ; 1F67: 
                   // FCB   $00                     ; 1F68: 
                   // FCB   $00                     ; 1F69: 
                   // FCB   $00                     ; 1F6A: 
                   // FCB   $00                     ; 1F6B: 
                   // FCB   $0F                     ; 1F6C: 
                   // FCB   $C0                     ; 1F6D: 
                   // FCB   $0F                     ; 1F6E: 
                   // FCB   $C0                     ; 1F6F: 
                   // FCB   $00                     ; 1F70: 
                   // FCB   $00                     ; 1F71: 
                   // FCB   $00                     ; 1F72: 
                   // FCB   $00                     ; 1F73: 
                   // FCB   $00                     ; 1F74: 
                   // FCB   $00                     ; 1F75: 
                   // FCB   $00                     ; 1F76: 
                   // FCB   $00                     ; 1F77: 
                   // FCB   $00                     ; 1F78: 
                   // FCB   $00                     ; 1F79: 
                   // FCB   $7F                     ; 1F7A: 
                   // FCB   $F8                     ; 1F7B: 
                   // FCB   $00                     ; 1F7C: 
                   // FCB   $00                     ; 1F7D: 
                   // FCB   $00                     ; 1F7E: 
                   // FCB   $00                     ; 1F7F: 
                   // FCB   $00                     ; 1F80: 
                   // FCB   $00                     ; 1F81: 
                   // FCB   $00                     ; 1F82: 
                   // FCB   $00                     ; 1F83: 
                   // FCB   $00                     ; 1F84: 
                   // FCB   $00                     ; 1F85: 
                   // FCB   $00                     ; 1F86: 
                   // FCB   $00                     ; 1F87: 
                   // FCB   $00                     ; 1F88: 
                   // FCB   $00                     ; 1F89: 
                   // FCB   $00                     ; 1F8A: 
                   // FCB   $00                     ; 1F8B: 
                   // FCB   $00                     ; 1F8C: 
                   // FCB   $00                     ; 1F8D: 
                   // FCB   $00                     ; 1F8E: 
                   // FCB   $00                     ; 1F8F: 
                   // FCB   $00                     ; 1F90: 
                   // FCB   $01                     ; 1F91: 
                   // FCB   $02                     ; 1F92: 
                   // FCB   $03                     ; 1F93: 
                   // FCB   $04                     ; 1F94: 
                   // FCB   $05                     ; 1F95: 
                   // FCB   $06                     ; 1F96: 
                   // FCB   $07                     ; 1F97: 
                   // FCB   $08                     ; 1F98: 
                   // FCB   $09                     ; 1F99: 
                   // FCB   $0A                     ; 1F9A: 
                   // FCB   $0B                     ; 1F9B: 
                   // FCB   $0C                     ; 1F9C: 
                   // FCB   $01                     ; 1F9D: 
                   // FCB   $02                     ; 1F9E: 
                   // FCB   $03                     ; 1F9F: 
                   // FCB   $04                     ; 1FA0: 
                   // FCB   $05                     ; 1FA1: 
                   // FCB   $06                     ; 1FA2: 
                   // FCB   $07                     ; 1FA3: 
                   // FCB   $08                     ; 1FA4: 
                   // FCB   $09                     ; 1FA5: 
                   // FCB   $0A                     ; 1FA6: 
                   // FCB   $0B                     ; 1FA7: 
                   // FCB   $0C                     ; 1FA8: 
                   // FCB   $00                     ; 1FA9: 
                   // FCB   $FF                     ; 1FAA: 
                   // FCB   $00                     ; 1FAB: 
                   // FCB   $00                     ; 1FAC: 
                   // FCB   $00                     ; 1FAD: 
                   // FCB   $18                     ; 1FAE: 
                   // FCB   $00                     ; 1FAF: 
                   // FCB   $BC                     ; 1FB0: 
                   // FCB   $00                     ; 1FB1: 
                   // FCB   $42                     ; 1FB2: 
                   // FCB   $00                     ; 1FB3: 
                   // FCB   $BC                     ; 1FB4: 
                   // FCB   $00                     ; 1FB5: 
                   // FCB   $00                     ; 1FB6: 
                   // FCB   $00                     ; 1FB7: 
                   // FCB   $00                     ; 1FB8: 
                   // FCB   $FC                     ; 1FB9: 
                   // FCB   $30                     ; 1FBA: 
                   // FCB   $6E                     ; 1FBB: 
                   // FCB   $7A                     ; 1FBC: 
                   // FCB   $B2                     ; 1FBD: 
                   // FCB   $DA                     ; 1FBE: 
                   // FCB   $DE                     ; 1FBF: 
                   // FCB   $70                     ; 1FC0: 
                   // FCB   $FE                     ; 1FC1: 
                   // FCB   $FA                     ; 1FC2: 
                   // FCB   $18                     ; 1FC3: 
                   // FCB   $03                     ; 1FC4: 
                   // FCB   $00                     ; 1FC5: 
                   // FCB   $18                     ; 1FC6: 
                   // FCB   $E8                     ; 1FC7: 
                   // FCB   $FD                     ; 1FC8: 
                   // FCB   $E8                     ; 1FC9: 
                   // FCB   $FD                     ; 1FCA: 
                   // FCB   $00                     ; 1FCB: 
                   // FCB   $E8                     ; 1FCC: 
                   // FCB   $18                     ; 1FCD: 
                   // FCB   $03                     ; 1FCE: 
                   // FCB   $00                     ; 1FCF: 
                   // FCB   $18                     ; 1FD0: 
                   // FCB   $02                     ; 1FD1: 
                   // FCB   $14                     ; 1FD2: 
                   // FCB   $00                     ; 1FD3: 
                   // FCB   $00                     ; 1FD4: 
                   // FCB   $03                     ; 1FD5: 
                   // FCB   $00                     ; 1FD6: 
                   // FCB   $04                     ; 1FD7: 
                   // FCB   $80                     ; 1FD8: 
                   // FCB   $06                     ; 1FD9: 
                   // FCB   $00                     ; 1FDA: 
                   // FCB   $25                     ; 1FDB: 
                   // FCB   $00                     ; 1FDC: 
                   // FCB   $80                     ; 1FDD: 
                   // FCB   $04                     ; 1FDE: 
                   // FCB   $00                     ; 1FDF: 
                   // FCB   $06                     ; 1FE0: 
                   // FCB   $00                     ; 1FE1: 
                   // FCB   $08                     ; 1FE2: 
                   // FCB   $00                     ; 1FE3: 
                   // FCB   $20                     ; 1FE4: 
                   // FCB   $00                     ; 1FE5: 
                   // FCB   $C0                     ; 1FE6: 
                   // FCB   $06                     ; 1FE7: 
                   // FCB   $00                     ; 1FE8: 
                   // FCB   $09                     ; 1FE9: 
                   // FCB   $00                     ; 1FEA: 
                   // FCB   $0C                     ; 1FEB: 
                   // FCB   $00                     ; 1FEC: 
                   // FCB   $15                     ; 1FED: 
                   // FCB   $01                     ; 1FEE: 
                   // FCB   $00                     ; 1FEF: 
                   // FCB   $08                     ; 1FF0: 
                   // FCB   $00                     ; 1FF1: 
                   // FCB   $0C                     ; 1FF2: 
                   // FCB   $00                     ; 1FF3: 
                   // FCB   $10                     ; 1FF4: 
                   // FCB   $00                     ; 1FF5: 
                   // FCB   $07                     ; 1FF6: 
                   // FCB   $02                     ; 1FF7: 
                   // FCB   $00                     ; 1FF8: 
                   // FCB   $0C                     ; 1FF9: 
                   // FCB   $00                     ; 1FFA: 
                   // FCB   $12                     ; 1FFB: 
                   // FCB   $00                     ; 1FFC: 
                   // FCB   $18                     ; 1FFD: 
                   // FCB   $00                     ; 1FFE: 
                   // FCB   $05                     ; 1FFF: