                   // ORG   $6000
    // ===========================================================================
    // Segment type: Pure code
  case 0x6000:
                                                     mon("L6000    JMP   $F261                   ; 6000: 7E F2 61      \n"); // segment ROM
    clockticks = clockticks + 4; 
    PC = 0xf261; 
    JUMP;
    
                   // FCB   $EF                     ; 6003:  ' ' EF 56          STU   -10,U ; 
                   // FCB   $56                     ; 6004:  'V' 56             RORB  ; V
    // =============== S U B R O U T I N E =======================================
  case 0x670D:
                                                     mon("L670D    LDX   #$496F                  ; 670D: 8E 49 6F      \n"); // "Bank 1"
    clockticks = clockticks + 3; 
    X = 0x496f; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6710; JUMP; // sstep
case 0x6710:
                                                     mon("         LDA   #$00                    ; 6710: 86 00         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x00; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6712; JUMP; // sstep
case 0x6712:
                                                     mon("L6712    STA   ,X+                     ; 6712: A7 80         \n");
    clockticks = clockticks + 6; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, val); 
    X = X + 1; 
    PC = 0x6714; JUMP; // sstep
case 0x6714:
                                                     mon("         CMPX  #$4989                  ; 6714: 8C 49 89      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x4989; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6717; JUMP; // sstep
case 0x6717:
                                                     mon("         BCS   $6712                   ; 6717: 25 F9         \n");
    // temp fix to ensure flags synched
    if (C) {
    PC = 0x6712; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6719; JUMP; // sstep
case 0x6719:
                                                     mon("         LDA   #$60                    ; 6719: 86 60         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x60; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x671B; JUMP; // sstep
case 0x671B:
                                                     mon("         LSRA                          ; 671B: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x671C; JUMP; // sstep
case 0x671C:
                                                     mon("         STA   <$D2                    ; 671C: 97 D2         \n");
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0xd2; 
    wr_mem(ea, val); 
    PC = 0x671E; JUMP; // sstep
case 0x671E:
                                                     mon("         LDD   #$5300                  ; 671E: CC 53 00      \n");
    clockticks = clockticks + 3; 
    A = 0x53; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6721; JUMP; // sstep
case 0x6721:
                                                     mon("         STD   <$D4                    ; 6721: DD D4         \n");
    clockticks = clockticks + 4; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = DP|0xd4; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    // End of function sub_670D
    PC = 0x6723; JUMP; // sstep
case 0x6723:
                                                     mon("         RTS                           ; 6723: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6724:
                                                     mon("L6724    STB   <$DC                    ; 6724: D7 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0xdc; 
    wr_mem(ea, val); 
    PC = 0x6726; JUMP; // sstep
case 0x6726:
                                                     mon("L6726    LDB   <$DC                    ; 6726: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6728; JUMP; // sstep
case 0x6728:
                                                     mon("         LDX   #$496F                  ; 6728: 8E 49 6F      \n");
    clockticks = clockticks + 3; 
    X = 0x496f; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x672B; JUMP; // sstep
case 0x672B:
                                                     mon("         LDA   B,X                     ; 672B: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x672D; JUMP; // sstep
case 0x672D:
                                                     mon("         BNE   $6760                   ; 672D: 26 31         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x6760; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x672F; JUMP; // sstep
case 0x672F:
                                                     mon("         LDA   <$D2                    ; 672F: 96 D2         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xd2); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6731; JUMP; // sstep
case 0x6731:
                                                     mon("         STA   B,X                     ; 6731: A7 85         \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = (UINT16)(X + (SINT8)B); 
    wr_mem(ea, val); 
    PC = 0x6733; JUMP; // sstep
case 0x6733:
                                                     mon("         LDX   #$7644                  ; 6733: 8E 76 44      \n"); // Array of object sizes?
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6736; JUMP; // sstep
case 0x6736:
                                                     mon("         LDA   B,X                     ; 6736: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6738; JUMP; // sstep
case 0x6738:
                                                     mon("         STA   <$01                    ; 6738: 97 01         \n"); // Number of points in object?
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x01; 
    wr_mem(ea, val); 
    PC = 0x673A; JUMP; // sstep
case 0x673A:
                                                     mon("         LSRA                          ; 673A: 44            \n");
    val = (UINT8)A; 
/**/C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x673B; JUMP; // sstep
case 0x673B:
                                                     mon("         ADDA  <$D2                    ; 673B: 9B D2         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)A; 
    arg = rd_mem(DP|0xd2); 
    res = val + (UINT8)arg; 
    C = (res >> 1) & 0x80; 
    Z = (UINT8)res; 
    N = (UINT8)res; 
    H = (UINT8)((val ^ arg) ^ (res ^ C)); 
    V = (UINT8)((val ^ arg) ^ (res ^ C)); 
    A = (UINT8)res; 
    PC = 0x673D; JUMP; // sstep
case 0x673D:
                                                     mon("         BCC   $6740                   ; 673D: 24 01         \n");
    // temp fix to ensure flags synched
    if (!C) {
    PC = 0x6740; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x673F; JUMP; // sstep
case 0x673F:
                                                     mon("         SWI                           ; 673F: 3F            \n");
    clockticks = clockticks + 19; 
    S = S - 1; 
    wr_mem(S, 0x40); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, U); 
    S = S - 1; 
    wr_mem(S, U >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, Y); 
    S = S - 1; 
    wr_mem(S, Y >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, X); 
    S = S - 1; 
    wr_mem(S, X >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, (DP >> 8)); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, B); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, A); 
    clockticks = clockticks + 1; 
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; // Placeholder for now
    restore_flags();
    S = S - 1; 
    wr_mem(S, CC); 
    clockticks = clockticks + 1; 
    PC = (rd_mem(0xfffa)<<8)|rd_mem(0xfffb); 
    JUMP;
  case 0x6740:
                                                     mon("L6740    STA   <$D2                    ; 6740: 97 D2         \n");
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0xd2; 
    wr_mem(ea, val); 
    PC = 0x6742; JUMP; // sstep
case 0x6742:
                                                     mon("         LDX   #$765E                  ; 6742: 8E 76 5E      \n"); // Table of pointers to object X, Y, Z point data?
    clockticks = clockticks + 3; 
    X = 0x765e; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6745; JUMP; // sstep
case 0x6745:
                                                     mon("         ASLB                          ; 6745: 58            \n");
    val = (UINT8)B; 
    res = val << 1; 
    C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    B = res; 
    clockticks = clockticks + 2; 
    PC = 0x6746; JUMP; // sstep
case 0x6746:
                                                     mon("         LDX   B,X                     ; 6746: AE 85         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + (SINT8)B))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + (SINT8)B))+1)); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6748; JUMP; // sstep
case 0x6748:
                                                     mon("         LDU   <$D4                    ; 6748: DE D4         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd4)<<8; 
    ea = ea | rd_mem(DP|0xd5); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x674A; JUMP; // sstep
case 0x674A:
                                                     mon("L674A    LDD   ,X                      ; 674A: EC 84         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(X); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(X+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x674C; JUMP; // sstep
case 0x674C:
                                                     mon("         STD   ,U                      ; 674C: ED C4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = U; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x674E; JUMP; // sstep
case 0x674E:
                                                     mon("         LDD   $02,X                   ; 674E: EC 02         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6750; JUMP; // sstep
case 0x6750:
                                                     mon("         STD   $02,U                   ; 6750: ED 42         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6752; JUMP; // sstep
case 0x6752:
                                                     mon("         LDD   $04,X                   ; 6752: EC 04         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0004); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6754; JUMP; // sstep
case 0x6754:
                                                     mon("         STD   $04,U                   ; 6754: ED 44         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6756; JUMP; // sstep
case 0x6756:
                                                     mon("         LEAX  $06,X                   ; 6756: 30 06         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0006); 
/**/Z = X; 
    PC = 0x6758; JUMP; // sstep
case 0x6758:
                                                     mon("         LEAU  $08,U                   ; 6758: 33 48         \n");
    clockticks = clockticks + 5; 
    U = (U + 0x0008); 
    PC = 0x675A; JUMP; // sstep
case 0x675A:
                                                     mon("         DEC   <$01                    ; 675A: 0A 01         \n"); // Loop count for object points
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x01); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x01, res); 
    clockticks = clockticks + 2; 
    PC = 0x675C; JUMP; // sstep
case 0x675C:
                                                     mon("         BGT   $674A                   ; 675C: 2E EC         \n"); // Copy XYZ data to math RAM
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x674a; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x675E; JUMP; // sstep
case 0x675E:
                                                     mon("         STU   <$D4                    ; 675E: DF D4         \n");
    clockticks = clockticks + 4; 
    val = U; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = DP|0xd4; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    // End of function sub_6724
    PC = 0x6760; JUMP; // sstep
case 0x6760:
                                                     mon("L6760    RTS                           ; 6760: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6761:
                                                     mon("L6761    LDD   $4700                   ; 6761: FC 47 00      \n"); // Called during space, towers and trench
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6764; JUMP; // sstep
case 0x6764:
                                                     mon("         STD   $5000                   ; 6764: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6767; JUMP; // sstep
case 0x6767:
                                                     mon("         LDA   #$86                    ; 6767: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6769; JUMP; // sstep
case 0x6769:
                                                     mon("         JSR   $CDBA                   ; 6769: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x6c); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x676C:
                                                     mon("L676C    LDD   $5004                   ; 676C: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x676F; JUMP; // sstep
case 0x676F:
                                                     mon("         STD   <$D8                    ; 676F: DD D8         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = DP|0xd8; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6771; JUMP; // sstep
case 0x6771:
                                                     mon("         ADDD  #$FF98                  ; 6771: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x6774; JUMP; // sstep
case 0x6774:
                                                     mon("         ANDA  #$1F                    ; 6774: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6776; JUMP; // sstep
case 0x6776:
                                                     mon("         STD   ,Y++                    ; 6776: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x6778; JUMP; // sstep
case 0x6778:
                                                     mon("         LDD   $5002                   ; 6778: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x677B; JUMP; // sstep
case 0x677B:
                                                     mon("         STD   <$D6                    ; 677B: DD D6         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = DP|0xd6; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x677D; JUMP; // sstep
case 0x677D:
                                                     mon("         ANDA  #$1F                    ; 677D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x677F; JUMP; // sstep
case 0x677F:
                                                     mon("         STD   ,Y++                    ; 677F: ED A1         \n");
    clockticks = clockticks + 7; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    // End of function sub_6761
    PC = 0x6781; JUMP; // sstep
case 0x6781:
                                                     mon("         RTS                           ; 6781: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6782:
                                                     mon("L6782    LDD   $4700                   ; 6782: FC 47 00      \n"); // Calc trench floor lines
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6785; JUMP; // sstep
case 0x6785:
                                                     mon("         STD   $5000                   ; 6785: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6788; JUMP; // sstep
case 0x6788:
                                                     mon("         LDA   #$86                    ; 6788: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x678A; JUMP; // sstep
case 0x678A:
                                                     mon("         JSR   $CDBA                   ; 678A: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x8d); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x678D:
                                                     mon("L678D    LDD   $5004                   ; 678D: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6790; JUMP; // sstep
case 0x6790:
                                                     mon("         SUBD  <$D8                    ; 6790: 93 D8         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd8)<<8; 
    ea = ea | rd_mem(DP|0xd9); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6792; JUMP; // sstep
case 0x6792:
                                                     mon("         ANDA  #$1F                    ; 6792: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6794; JUMP; // sstep
case 0x6794:
                                                     mon("         STD   ,Y++                    ; 6794: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x6796; JUMP; // sstep
case 0x6796:
                                                     mon("         LDD   $5004                   ; 6796: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6799; JUMP; // sstep
case 0x6799:
                                                     mon("         STD   <$D8                    ; 6799: DD D8         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = DP|0xd8; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x679B; JUMP; // sstep
case 0x679B:
                                                     mon("         LDD   $5002                   ; 679B: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x679E; JUMP; // sstep
case 0x679E:
                                                     mon("         SUBD  <$D6                    ; 679E: 93 D6         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd6)<<8; 
    ea = ea | rd_mem(DP|0xd7); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x67A0; JUMP; // sstep
case 0x67A0:
                                                     mon("         ORA   #$E0                    ; 67A0: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x67A2; JUMP; // sstep
case 0x67A2:
                                                     mon("         STD   ,Y++                    ; 67A2: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x67A4; JUMP; // sstep
case 0x67A4:
                                                     mon("         LDD   $5002                   ; 67A4: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67A7; JUMP; // sstep
case 0x67A7:
                                                     mon("         STD   <$D6                    ; 67A7: DD D6         \n");
    clockticks = clockticks + 4; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = DP|0xd6; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    // End of function sub_6782
    PC = 0x67A9; JUMP; // sstep
case 0x67A9:
                                                     mon("         RTS                           ; 67A9: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x67AA:
                                                     mon("L67AA    LDD   $4700                   ; 67AA: FC 47 00      \n"); // Calc trench vertical lines on walls
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67AD; JUMP; // sstep
case 0x67AD:
                                                     mon("         STD   $5000                   ; 67AD: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x67B0; JUMP; // sstep
case 0x67B0:
                                                     mon("         LDA   #$86                    ; 67B0: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x67B2; JUMP; // sstep
case 0x67B2:
                                                     mon("         JSR   $CDBA                   ; 67B2: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xb5); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x67B5:
                                                     mon("L67B5    LDD   $5004                   ; 67B5: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67B8; JUMP; // sstep
case 0x67B8:
                                                     mon("         SUBD  <$D8                    ; 67B8: 93 D8         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd8)<<8; 
    ea = ea | rd_mem(DP|0xd9); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x67BA; JUMP; // sstep
case 0x67BA:
                                                     mon("         ANDA  #$1F                    ; 67BA: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x67BC; JUMP; // sstep
case 0x67BC:
                                                     mon("         STD   ,Y++                    ; 67BC: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x67BE; JUMP; // sstep
case 0x67BE:
                                                     mon("         LDD   $5004                   ; 67BE: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67C1; JUMP; // sstep
case 0x67C1:
                                                     mon("         STD   <$D8                    ; 67C1: DD D8         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = DP|0xd8; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x67C3; JUMP; // sstep
case 0x67C3:
                                                     mon("         LDD   $5002                   ; 67C3: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67C6; JUMP; // sstep
case 0x67C6:
                                                     mon("         SUBD  <$D6                    ; 67C6: 93 D6         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd6)<<8; 
    ea = ea | rd_mem(DP|0xd7); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x67C8; JUMP; // sstep
case 0x67C8:
                                                     mon("         ANDA  #$1F                    ; 67C8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x67CA; JUMP; // sstep
case 0x67CA:
                                                     mon("         STD   ,Y++                    ; 67CA: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x67CC; JUMP; // sstep
case 0x67CC:
                                                     mon("         LDD   $5002                   ; 67CC: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67CF; JUMP; // sstep
case 0x67CF:
                                                     mon("         STD   <$D6                    ; 67CF: DD D6         \n");
    clockticks = clockticks + 4; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = DP|0xd6; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    // End of function sub_67AA
    PC = 0x67D1; JUMP; // sstep
case 0x67D1:
                                                     mon("         RTS                           ; 67D1: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
    // End of function sub_67D2
  case 0x67D2:
                                                     mon("L67D2    STB   <$DC                    ; 67D2: D7 DC         \n"); // Called during space
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0xdc; 
    wr_mem(ea, val); 
    // =============== S U B R O U T I N E =======================================
    PC = 0x67D4; JUMP; // sstep
case 0x67D4:
                                                     mon("L67D4    LDB   <$DC                    ; 67D4: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x67D6; JUMP; // sstep
case 0x67D6:
                                                     mon("         LDX   #$7644                  ; 67D6: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x67D9; JUMP; // sstep
case 0x67D9:
                                                     mon("         LDA   B,X                     ; 67D9: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x67DB; JUMP; // sstep
case 0x67DB:
                                                     mon("         STA   <$01                    ; 67DB: 97 01         \n"); // Loop count for object points
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x01; 
    wr_mem(ea, val); 
    PC = 0x67DD; JUMP; // sstep
case 0x67DD:
                                                     mon("         LDX   #$496F                  ; 67DD: 8E 49 6F      \n");
    clockticks = clockticks + 3; 
    X = 0x496f; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x67E0; JUMP; // sstep
case 0x67E0:
                                                     mon("         LDA   B,X                     ; 67E0: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x67E2; JUMP; // sstep
case 0x67E2:
                                                     mon("         BNE   $67E5                   ; 67E2: 26 01         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x67e5; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x67E4; JUMP; // sstep
case 0x67E4:
                                                     mon("         SWI                           ; 67E4: 3F            \n");
    clockticks = clockticks + 19; 
    S = S - 1; 
    wr_mem(S, 0xe5); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, U); 
    S = S - 1; 
    wr_mem(S, U >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, Y); 
    S = S - 1; 
    wr_mem(S, Y >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, X); 
    S = S - 1; 
    wr_mem(S, X >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, (DP >> 8)); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, B); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, A); 
    clockticks = clockticks + 1; 
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; // Placeholder for now
    restore_flags();
    S = S - 1; 
    wr_mem(S, CC); 
    clockticks = clockticks + 1; 
    PC = (rd_mem(0xfffa)<<8)|rd_mem(0xfffb); 
    JUMP;
  case 0x67E5:
                                                     mon("L67E5    ASLA                          ; 67E5: 48            \n");
    val = (UINT8)A; 
    res = val << 1; 
    C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x67E6; JUMP; // sstep
case 0x67E6:
                                                     mon("         STA   $4702                   ; 67E6: B7 47 02      \n"); // Set BIC
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4702, val); 
    PC = 0x67E9; JUMP; // sstep
case 0x67E9:
                                                     mon("         ROLA                          ; 67E9: 49            \n");
    val = (UINT8)A; 
    res = (val << 1) + (C != 0 ?1:0); 
    C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    A = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x67EA; JUMP; // sstep
case 0x67EA:
                                                     mon("         STA   $4701                   ; 67EA: B7 47 01      \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4701, val); 
    PC = 0x67ED; JUMP; // sstep
case 0x67ED:
                                                     mon("         LDX   #$4C00                  ; 67ED: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x67F0; JUMP; // sstep
case 0x67F0:
                                                     mon("L67F0    LDA   #$50                    ; 67F0: 86 50         \n"); // Math program 0x50. Matrix Multiply - Transposed
    clockticks = clockticks + 2; 
    val = (UINT8)0x50; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x67F2; JUMP; // sstep
case 0x67F2:
                                                     mon("         JSR   $CDBA                   ; 67F2: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xf5); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x67); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x67F5:
                                                     mon("L67F5    LDD   $5000                   ; 67F5: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x67F8; JUMP; // sstep
case 0x67F8:
                                                     mon("         STD   $4704                   ; 67F8: FD 47 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x67FB; JUMP; // sstep
case 0x67FB:
                                                     mon("         ORCC  #$00                    ; 67FB: 1A 00         \n");
    clockticks = clockticks + 3; 
    PC = 0x67FD; JUMP; // sstep
case 0x67FD:
                                                     mon("         LDD   $4700                   ; 67FD: FC 47 00      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6800; JUMP; // sstep
case 0x6800:
                                                     mon("         STD   $5000                   ; 6800: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6803; JUMP; // sstep
case 0x6803:
                                                     mon("         LDA   #$86                    ; 6803: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6805; JUMP; // sstep
case 0x6805:
                                                     mon("         JSR   $CDBA                   ; 6805: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x08); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x68); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x6808:
                                                     mon("L6808    LDD   $5002                   ; 6808: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x680B; JUMP; // sstep
case 0x680B:
                                                     mon("         STD   ,X                      ; 680B: ED 84         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x680D; JUMP; // sstep
case 0x680D:
                                                     mon("         LDD   $5004                   ; 680D: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6810; JUMP; // sstep
case 0x6810:
                                                     mon("         STD   $02,X                   ; 6810: ED 02         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6812; JUMP; // sstep
case 0x6812:
                                                     mon("         LEAX  $04,X                   ; 6812: 30 04         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0004); 
/**/Z = X; 
    PC = 0x6814; JUMP; // sstep
case 0x6814:
                                                     mon("         DEC   <$01                    ; 6814: 0A 01         \n"); // Loop until all object points done
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x01); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x01, res); 
    clockticks = clockticks + 2; 
    PC = 0x6816; JUMP; // sstep
case 0x6816:
                                                     mon("         BGT   $67F0                   ; 6816: 2E D8         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x67f0; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    // End of function sub_67D4
    PC = 0x6818; JUMP; // sstep
case 0x6818:
                                                     mon("         RTS                           ; 6818: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
    // Format vectors for ties, and tower/bunker explosions
  case 0x6819:
                                                     mon("L6819    LDX   #$7610                  ; 6819: 8E 76 10      \n"); // Called during space and towers
    clockticks = clockticks + 3; 
    X = 0x7610; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x681C; JUMP; // sstep
case 0x681C:
                                                     mon("         LDB   <$DC                    ; 681C: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x681E; JUMP; // sstep
case 0x681E:
                                                     mon("         ASLB                          ; 681E: 58            \n");
    val = (UINT8)B; 
    res = val << 1; 
    C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    B = res; 
    clockticks = clockticks + 2; 
    PC = 0x681F; JUMP; // sstep
case 0x681F:
                                                     mon("         LDU   B,X                     ; 681F: EE 85         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + (SINT8)B))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + (SINT8)B))+1)); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6821; JUMP; // sstep
case 0x6821:
                                                     mon("         LDB   ,U+                     ; 6821: E6 C0         \n");
    clockticks = clockticks + 6; 
    val = (UINT8)rd_mem(U); 
    B = val; 
    N = val; 
    Z = val; 
    V = 0; 
    U = U + 1; 
    PC = 0x6823; JUMP; // sstep
case 0x6823:
                                                     mon("         BEQ   $6826                   ; 6823: 27 01         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x6826; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6825; JUMP; // sstep
case 0x6825:
                                                     mon("         SWI                           ; 6825: 3F            \n");
    clockticks = clockticks + 19; 
    S = S - 1; 
    wr_mem(S, 0x26); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x68); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, U); 
    S = S - 1; 
    wr_mem(S, U >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, Y); 
    S = S - 1; 
    wr_mem(S, Y >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, X); 
    S = S - 1; 
    wr_mem(S, X >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, (DP >> 8)); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, B); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, A); 
    clockticks = clockticks + 1; 
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; // Placeholder for now
    restore_flags();
    S = S - 1; 
    wr_mem(S, CC); 
    clockticks = clockticks + 1; 
    PC = (rd_mem(0xfffa)<<8)|rd_mem(0xfffb); 
    JUMP;
  case 0x6826:
                                                     mon("L6826    LDB   ,U+                     ; 6826: E6 C0         \n");
    clockticks = clockticks + 6; 
    val = (UINT8)rd_mem(U); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    U = U + 1; 
    PC = 0x6828; JUMP; // sstep
case 0x6828:
                                                     mon("         BITB  #$02                    ; 6828: C5 02         \n");
    clockticks = clockticks + 2; 
    res = B & (SINT8)0x02; 
    Z = res; 
    N = res; 
    V = 0; 
    PC = 0x682A; JUMP; // sstep
case 0x682A:
                                                     mon("         BEQ   $6838                   ; 682A: 27 0C         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x6838; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x682C; JUMP; // sstep
case 0x682C:
                                                     mon("         CMPB  #$FF                    ; 682C: C1 FF         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    arg = 0xff; 
    res = val - (UINT8)arg; 
    C = res & 0x100; 
    Z = (UINT8)res; 
    N = (UINT8)res; 
    V = (UINT8)((val ^ arg) & (val ^ res)); 
    PC = 0x682E; JUMP; // sstep
case 0x682E:
                                                     mon("         BEQ   $6863                   ; 682E: 27 33         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x6863; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6830; JUMP; // sstep
case 0x6830:
                                                     mon("         LSRB                          ; 6830: 54            \n");
    val = (UINT8)B; 
/**/C = val & 1; 
    val = val >> 1; 
    B = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x6831; JUMP; // sstep
case 0x6831:
                                                     mon("         LSRB                          ; 6831: 54            \n");
    val = (UINT8)B; 
/**/C = val & 1; 
    val = val >> 1; 
    B = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x6832; JUMP; // sstep
case 0x6832:
                                                     mon("         CMPB  <$DB                    ; 6832: D1 DB         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)B; 
    arg = rd_mem(DP|0xdb); 
    res = val - (UINT8)arg; 
    C = res & 0x100; 
    Z = (UINT8)res; 
    N = (UINT8)res; 
    V = (UINT8)((val ^ arg) & (val ^ res)); 
    PC = 0x6834; JUMP; // sstep
case 0x6834:
                                                     mon("         BHI   $6826                   ; 6834: 22 F0         \n");
    // temp fix to ensure flags synched
    if (Z && (!C)) {
    PC = 0x6826; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6836; JUMP; // sstep
case 0x6836:
                                                     mon("         BRA   $6863                   ; 6836: 20 2B         \n");
    PC = 0x6863; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x6838:
                                                     mon("L6838    CLRA                          ; 6838: 4F            \n");
    A = 0; 
/**/V = 0; 
/**/Z = 0; 
/**/N = 0; 
    C = 0; 
    clockticks = clockticks + 2; 
    PC = 0x6839; JUMP; // sstep
case 0x6839:
                                                     mon("         BITB  #$03                    ; 6839: C5 03         \n");
    clockticks = clockticks + 2; 
    res = B & (SINT8)0x03; 
    Z = res; 
    N = res; 
    V = 0; 
    PC = 0x683B; JUMP; // sstep
case 0x683B:
                                                     mon("         BNE   $683F                   ; 683B: 26 02         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x683f; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x683D; JUMP; // sstep
case 0x683D:
                                                     mon("         LDA   #$E0                    ; 683D: 86 E0         \n"); // Vector is visible
    clockticks = clockticks + 2; 
    val = (UINT8)0xe0; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x683F; JUMP; // sstep
case 0x683F:
                                                     mon("L683F    STA   <$DA                    ; 683F: 97 DA         \n");
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0xda; 
    wr_mem(ea, val); 
    PC = 0x6841; JUMP; // sstep
case 0x6841:
                                                     mon("         ANDB  #$FC                    ; 6841: C4 FC         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    res = val & (SINT8)0xfc; 
    B = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6843; JUMP; // sstep
case 0x6843:
                                                     mon("         LDX   #$4C00                  ; 6843: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6846; JUMP; // sstep
case 0x6846:
                                                     mon("         ABX                           ; 6846: 3A            \n");
    X = X + B; 
    clockticks = clockticks + 3; 
    PC = 0x6847; JUMP; // sstep
case 0x6847:
                                                     mon("         LDD   $02,X                   ; 6847: EC 02         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6849; JUMP; // sstep
case 0x6849:
                                                     mon("         SUBD  <$D8                    ; 6849: 93 D8         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd8)<<8; 
    ea = ea | rd_mem(DP|0xd9); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x684B; JUMP; // sstep
case 0x684B:
                                                     mon("         ANDA  #$1F                    ; 684B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x684D; JUMP; // sstep
case 0x684D:
                                                     mon("         STD   ,Y++                    ; 684D: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x684F; JUMP; // sstep
case 0x684F:
                                                     mon("         LDD   ,X                      ; 684F: EC 84         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(X); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(X+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6851; JUMP; // sstep
case 0x6851:
                                                     mon("         SUBD  <$D6                    ; 6851: 93 D6         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xd6)<<8; 
    ea = ea | rd_mem(DP|0xd7); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6853; JUMP; // sstep
case 0x6853:
                                                     mon("         ANDA  #$1F                    ; 6853: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6855; JUMP; // sstep
case 0x6855:
                                                     mon("         ORA   <$DA                    ; 6855: 9A DA         \n");
    clockticks = clockticks + 4; 
    res = A | (UINT8)rd_mem(DP|0xda); 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6857; JUMP; // sstep
case 0x6857:
                                                     mon("         STD   ,Y++                    ; 6857: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x6859; JUMP; // sstep
case 0x6859:
                                                     mon("         LDD   ,X                      ; 6859: EC 84         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(X); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(X+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x685B; JUMP; // sstep
case 0x685B:
                                                     mon("         STD   <$D6                    ; 685B: DD D6         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = DP|0xd6; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x685D; JUMP; // sstep
case 0x685D:
                                                     mon("         LDD   $02,X                   ; 685D: EC 02         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x685F; JUMP; // sstep
case 0x685F:
                                                     mon("         STD   <$D8                    ; 685F: DD D8         \n");
    clockticks = clockticks + 4; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = DP|0xd8; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6861; JUMP; // sstep
case 0x6861:
                                                     mon("         BRA   $6826                   ; 6861: 20 C3         \n");
    PC = 0x6826; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
    // End of function sub_6819
  case 0x6863:
                                                     mon("L6863    RTS                           ; 6863: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6864:
                                                     mon("L6864    LDD   #$00                    ; 6864: CC 00 00      \n"); // Left hand side of trench turret calculation
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6867; JUMP; // sstep
case 0x6867:
                                                     mon("         STD   $5040                   ; 6867: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x686A; JUMP; // sstep
case 0x686A:
                                                     mon("         STD   $5042                   ; 686A: FD 50 42      \n"); // Clear XT, YT and ZT to zero
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x686D; JUMP; // sstep
case 0x686D:
                                                     mon("         STD   $5044                   ; 686D: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    PC = 0x6870; JUMP; // sstep
case 0x6870:
                                                     mon("         LDX   #$7644                  ; 6870: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6873; JUMP; // sstep
case 0x6873:
                                                     mon("         LDB   <$DC                    ; 6873: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6875; JUMP; // sstep
case 0x6875:
                                                     mon("         LDA   B,X                     ; 6875: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6877; JUMP; // sstep
case 0x6877:
                                                     mon("         STA   <$01                    ; 6877: 97 01         \n"); // Loop count for object points
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x01; 
    wr_mem(ea, val); 
    PC = 0x6879; JUMP; // sstep
case 0x6879:
                                                     mon("         LDX   #$765E                  ; 6879: 8E 76 5E      \n");
    clockticks = clockticks + 3; 
    X = 0x765e; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x687C; JUMP; // sstep
case 0x687C:
                                                     mon("         ASLB                          ; 687C: 58            \n");
    val = (UINT8)B; 
    res = val << 1; 
    C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    B = res; 
    clockticks = clockticks + 2; 
    PC = 0x687D; JUMP; // sstep
case 0x687D:
                                                     mon("         LDU   B,X                     ; 687D: EE 85         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + (SINT8)B))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + (SINT8)B))+1)); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x687F; JUMP; // sstep
case 0x687F:
                                                     mon("         LDX   #$5DF0                  ; 687F: 8E 5D F0      \n");
    clockticks = clockticks + 3; 
    X = 0x5df0; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6882; JUMP; // sstep
case 0x6882:
                                                     mon("L6882    LDD   ,U++                    ; 6882: EC C1         \n");
    clockticks = clockticks + 7; 
    A = rd_mem(U); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(U+1)); 
    U = U + 2; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6884; JUMP; // sstep
case 0x6884:
                                                     mon("         STD   $5E00                   ; 6884: FD 5E 00      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e00, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e01, B); 
    PC = 0x6887; JUMP; // sstep
case 0x6887:
                                                     mon("         LDD   ,U++                    ; 6887: EC C1         \n");
    clockticks = clockticks + 7; 
    A = rd_mem(U); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(U+1)); 
    U = U + 2; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6889; JUMP; // sstep
case 0x6889:
                                                     mon("         STD   $5E02                   ; 6889: FD 5E 02      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e02, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e03, B); 
    PC = 0x688C; JUMP; // sstep
case 0x688C:
                                                     mon("         LDD   ,U++                    ; 688C: EC C1         \n");
    clockticks = clockticks + 7; 
    A = rd_mem(U); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(U+1)); 
    U = U + 2; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x688E; JUMP; // sstep
case 0x688E:
                                                     mon("         STD   $5E04                   ; 688E: FD 5E 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e04, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e05, B); 
    PC = 0x6891; JUMP; // sstep
case 0x6891:
                                                     mon("         LDD   #$01C0                  ; 6891: CC 01 C0      \n"); // Point BIC to Math RAM $5E00
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0xc0; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6894; JUMP; // sstep
case 0x6894:
                                                     mon("         STD   $4701                   ; 6894: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x6897; JUMP; // sstep
case 0x6897:
                                                     mon("         LDA   #$2A                    ; 6897: 86 2A         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x2a; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6899; JUMP; // sstep
case 0x6899:
                                                     mon("         JSR   $CDBA                   ; 6899: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x9c); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x68); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x689C:
                                                     mon("L689C    LDD   $5000                   ; 689C: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x689F; JUMP; // sstep
case 0x689F:
                                                     mon("         STD   $06,X                   ; 689F: ED 06         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x68A1; JUMP; // sstep
case 0x68A1:
                                                     mon("         LDD   $5002                   ; 68A1: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68A4; JUMP; // sstep
case 0x68A4:
                                                     mon("         STD   $18,X                   ; 68A4: ED 88 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x68A7; JUMP; // sstep
case 0x68A7:
                                                     mon("         LDD   $5004                   ; 68A7: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68AA; JUMP; // sstep
case 0x68AA:
                                                     mon("         STD   $1A,X                   ; 68AA: ED 88 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x68AD; JUMP; // sstep
case 0x68AD:
                                                     mon("         LEAX  $10,X                   ; 68AD: 30 88 10      \n");
    clockticks = clockticks + 5; 
    X = (X + (SINT8)0x10); 
/**/Z = X; 
    PC = 0x68B0; JUMP; // sstep
case 0x68B0:
                                                     mon("         DEC   <$01                    ; 68B0: 0A 01         \n"); // Loop until all object points done
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x01); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x01, res); 
    clockticks = clockticks + 2; 
    PC = 0x68B2; JUMP; // sstep
case 0x68B2:
                                                     mon("         BGT   $6882                   ; 68B2: 2E CE         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x6882; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x68B4; JUMP; // sstep
case 0x68B4:
                                                     mon("         LDD   $5098                   ; 68B4: FC 50 98      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5098); // Care needed with I/O space and word fetches
    B = rd_mem(0x5099); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68B7; JUMP; // sstep
case 0x68B7:
                                                     mon("         STD   $5040                   ; 68B7: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x68BA; JUMP; // sstep
case 0x68BA:
                                                     mon("         LDD   $509A                   ; 68BA: FC 50 9A      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509a); // Care needed with I/O space and word fetches
    B = rd_mem(0x509b); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68BD; JUMP; // sstep
case 0x68BD:
                                                     mon("         STD   $5042                   ; 68BD: FD 50 42      \n"); // YT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x68C0; JUMP; // sstep
case 0x68C0:
                                                     mon("         LDD   $509C                   ; 68C0: FC 50 9C      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509c); // Care needed with I/O space and word fetches
    B = rd_mem(0x509d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68C3; JUMP; // sstep
case 0x68C3:
                                                     mon("         STD   $5044                   ; 68C3: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    // End of function sub_6864
    PC = 0x68C6; JUMP; // sstep
case 0x68C6:
                                                     mon("         RTS                           ; 68C6: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x68C7:
                                                     mon("L68C7    LDD   #$00                    ; 68C7: CC 00 00      \n"); // Right hand side of trench turret calculation
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68CA; JUMP; // sstep
case 0x68CA:
                                                     mon("         STD   $5040                   ; 68CA: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x68CD; JUMP; // sstep
case 0x68CD:
                                                     mon("         STD   $5042                   ; 68CD: FD 50 42      \n"); // Clear XT, YT and ZT to zero
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x68D0; JUMP; // sstep
case 0x68D0:
                                                     mon("         STD   $5044                   ; 68D0: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    PC = 0x68D3; JUMP; // sstep
case 0x68D3:
                                                     mon("         LDX   #$7644                  ; 68D3: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x68D6; JUMP; // sstep
case 0x68D6:
                                                     mon("         LDB   <$DC                    ; 68D6: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x68D8; JUMP; // sstep
case 0x68D8:
                                                     mon("         LDA   B,X                     ; 68D8: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x68DA; JUMP; // sstep
case 0x68DA:
                                                     mon("         STA   <$01                    ; 68DA: 97 01         \n"); // Loop count for object points
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x01; 
    wr_mem(ea, val); 
    PC = 0x68DC; JUMP; // sstep
case 0x68DC:
                                                     mon("         LDX   #$765E                  ; 68DC: 8E 76 5E      \n");
    clockticks = clockticks + 3; 
    X = 0x765e; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x68DF; JUMP; // sstep
case 0x68DF:
                                                     mon("         ASLB                          ; 68DF: 58            \n");
    val = (UINT8)B; 
    res = val << 1; 
/**/C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    B = res; 
    clockticks = clockticks + 2; 
    PC = 0x68E0; JUMP; // sstep
case 0x68E0:
                                                     mon("         LDU   B,X                     ; 68E0: EE 85         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + (SINT8)B))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + (SINT8)B))+1)); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x68E2; JUMP; // sstep
case 0x68E2:
                                                     mon("         LDX   #$5DF0                  ; 68E2: 8E 5D F0      \n");
    clockticks = clockticks + 3; 
    X = 0x5df0; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x68E5; JUMP; // sstep
case 0x68E5:
                                                     mon("L68E5    LDD   ,U++                    ; 68E5: EC C1         \n");
    clockticks = clockticks + 7; 
    A = rd_mem(U); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(U+1)); 
    U = U + 2; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68E7; JUMP; // sstep
case 0x68E7:
                                                     mon("         STD   $5E00                   ; 68E7: FD 5E 00      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e00, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e01, B); 
    PC = 0x68EA; JUMP; // sstep
case 0x68EA:
                                                     mon("         LDD   #$00                    ; 68EA: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68ED; JUMP; // sstep
case 0x68ED:
                                                     mon("         SUBD  ,U++                    ; 68ED: A3 C1         \n"); // Negate
    clockticks = clockticks + 1; 
    clockticks = clockticks + 7; 
    clockticks = clockticks + 1; 
    ea = rd_mem(U)<<8; 
    ea = ea | rd_mem((UINT16)((U)+1)); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    U = U + 2; 
    PC = 0x68EF; JUMP; // sstep
case 0x68EF:
                                                     mon("         STD   $5E02                   ; 68EF: FD 5E 02      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e02, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e03, B); 
    PC = 0x68F2; JUMP; // sstep
case 0x68F2:
                                                     mon("         LDD   ,U++                    ; 68F2: EC C1         \n");
    clockticks = clockticks + 7; 
    A = rd_mem(U); // Care needed with I/O space and word fetches. Use 'ea' here?
    B = rd_mem((UINT16)(U+1)); 
    U = U + 2; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68F4; JUMP; // sstep
case 0x68F4:
                                                     mon("         STD   $5E04                   ; 68F4: FD 5E 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5e04, A); // Care needed with I/O space and word fetches
    wr_mem(0x5e05, B); 
    PC = 0x68F7; JUMP; // sstep
case 0x68F7:
                                                     mon("         LDD   #$01C0                  ; 68F7: CC 01 C0      \n"); // Point BIC to Math RAM $5E00
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0xc0; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x68FA; JUMP; // sstep
case 0x68FA:
                                                     mon("         STD   $4701                   ; 68FA: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x68FD; JUMP; // sstep
case 0x68FD:
                                                     mon("         LDA   #$2A                    ; 68FD: 86 2A         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x2a; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x68FF; JUMP; // sstep
case 0x68FF:
                                                     mon("         JSR   $CDBA                   ; 68FF: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x02); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x69); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x6902:
                                                     mon("L6902    LDD   $5000                   ; 6902: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6905; JUMP; // sstep
case 0x6905:
                                                     mon("         STD   $06,X                   ; 6905: ED 06         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6907; JUMP; // sstep
case 0x6907:
                                                     mon("         LDD   $5002                   ; 6907: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x690A; JUMP; // sstep
case 0x690A:
                                                     mon("         STD   $18,X                   ; 690A: ED 88 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x690D; JUMP; // sstep
case 0x690D:
                                                     mon("         LDD   $5004                   ; 690D: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6910; JUMP; // sstep
case 0x6910:
                                                     mon("         STD   $1A,X                   ; 6910: ED 88 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6913; JUMP; // sstep
case 0x6913:
                                                     mon("         LEAX  $10,X                   ; 6913: 30 88 10      \n");
    clockticks = clockticks + 5; 
    X = (X + (SINT8)0x10); 
/**/Z = X; 
    PC = 0x6916; JUMP; // sstep
case 0x6916:
                                                     mon("         DEC   <$01                    ; 6916: 0A 01         \n"); // Loop count for object points
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x01); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x01, res); 
    clockticks = clockticks + 2; 
    PC = 0x6918; JUMP; // sstep
case 0x6918:
                                                     mon("         BGT   $68E5                   ; 6918: 2E CB         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x68e5; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x691A; JUMP; // sstep
case 0x691A:
                                                     mon("         LDD   $5098                   ; 691A: FC 50 98      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5098); // Care needed with I/O space and word fetches
    B = rd_mem(0x5099); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x691D; JUMP; // sstep
case 0x691D:
                                                     mon("         STD   $5040                   ; 691D: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x6920; JUMP; // sstep
case 0x6920:
                                                     mon("         LDD   $509A                   ; 6920: FC 50 9A      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509a); // Care needed with I/O space and word fetches
    B = rd_mem(0x509b); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6923; JUMP; // sstep
case 0x6923:
                                                     mon("         STD   $5042                   ; 6923: FD 50 42      \n"); // YT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x6926; JUMP; // sstep
case 0x6926:
                                                     mon("         LDD   $509C                   ; 6926: FC 50 9C      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509c); // Care needed with I/O space and word fetches
    B = rd_mem(0x509d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6929; JUMP; // sstep
case 0x6929:
                                                     mon("         STD   $5044                   ; 6929: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    // End of function sub_68C7
    PC = 0x692C; JUMP; // sstep
case 0x692C:
                                                     mon("         RTS                           ; 692C: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x692D:
                                                     mon("L692D    LDD   #$00                    ; 692D: CC 00 00      \n"); // Trench calculation
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6930; JUMP; // sstep
case 0x6930:
                                                     mon("         SUBD  $5000                   ; 6930: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6933; JUMP; // sstep
case 0x6933:
                                                     mon("         STD   $5000                   ; 6933: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6936; JUMP; // sstep
case 0x6936:
                                                     mon("         LDD   #$00                    ; 6936: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6939; JUMP; // sstep
case 0x6939:
                                                     mon("         SUBD  $5002                   ; 6939: B3 50 02      \n"); // Math result Y
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5002)<<8; 
    ea = ea | rd_mem(0x5003); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x693C; JUMP; // sstep
case 0x693C:
                                                     mon("         STD   $5002                   ; 693C: FD 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5002, A); // Care needed with I/O space and word fetches
    wr_mem(0x5003, B); 
    PC = 0x693F; JUMP; // sstep
case 0x693F:
                                                     mon("         LDD   #$00                    ; 693F: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6942; JUMP; // sstep
case 0x6942:
                                                     mon("         SUBD  $5004                   ; 6942: B3 50 04      \n"); // Math result Z
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5004)<<8; 
    ea = ea | rd_mem(0x5005); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6945; JUMP; // sstep
case 0x6945:
                                                     mon("         STD   $5004                   ; 6945: FD 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5004, A); // Care needed with I/O space and word fetches
    wr_mem(0x5005, B); 
    PC = 0x6948; JUMP; // sstep
case 0x6948:
                                                     mon("         LDD   #$01C0                  ; 6948: CC 01 C0      \n"); // Point BIC to Math RAM $5E00
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0xc0; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x694B; JUMP; // sstep
case 0x694B:
                                                     mon("         STD   $4701                   ; 694B: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x694E; JUMP; // sstep
case 0x694E:
                                                     mon("         LDD   $5DF6                   ; 694E: FC 5D F6      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5df6); // Care needed with I/O space and word fetches
    B = rd_mem(0x5df7); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6951; JUMP; // sstep
case 0x6951:
                                                     mon("         SUBD  $5000                   ; 6951: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6954; JUMP; // sstep
case 0x6954:
                                                     mon("         STD   $4704                   ; 6954: FD 47 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x6957; JUMP; // sstep
case 0x6957:
                                                     mon("         LDA   #$B0                    ; 6957: 86 B0         \n"); // XT = [BIC,3] - Reg00, BIC++
    clockticks = clockticks + 2; 
    val = (UINT8)0xb0; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6959; JUMP; // sstep
case 0x6959:
                                                     mon("         STA   $4700                   ; 6959: B7 47 00      \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x695C; JUMP; // sstep
case 0x695C:
                                                     mon("         LDX   #$7644                  ; 695C: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x695F; JUMP; // sstep
case 0x695F:
                                                     mon("         LDB   <$DC                    ; 695F: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6961; JUMP; // sstep
case 0x6961:
                                                     mon("         LDA   B,X                     ; 6961: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6963; JUMP; // sstep
case 0x6963:
                                                     mon("         LDB   #$AE                    ; 6963: C6 AE         \n"); // [BIC,2] = ([BIC,0] - Reg01) x (YT), [BIC,3] = ([BIC,1] - Reg02) x (YT), BIC++, XT = (BIC,3) - Reg00, BIC++
    clockticks = clockticks + 2; 
    val = (UINT8)0xae; 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6965; JUMP; // sstep
case 0x6965:
                                                     mon("L6965    LDU   $4700                   ; 6965: FE 47 00      \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x4700)<<8; 
    ea = ea | rd_mem(0x4701); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6968; JUMP; // sstep
case 0x6968:
                                                     mon("         LDX   $5018                   ; 6968: BE 50 18      \n"); // XT
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5018)<<8; 
    ea = ea | rd_mem(0x5019); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x696B; JUMP; // sstep
case 0x696B:
                                                     mon("         STU   $501A                   ; 696B: FF 50 1A      \n"); // YT
    clockticks = clockticks + 5; 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x501a, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x501b, (UINT8)val); 
    PC = 0x696E; JUMP; // sstep
case 0x696E:
                                                     mon("         STB   $4700                   ; 696E: F7 47 00      \n"); // Run math program $AE
    clockticks = clockticks + 5; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x6971; JUMP; // sstep
case 0x6971:
                                                     mon("         STX   $4704                   ; 6971: BF 47 04      \n");
    clockticks = clockticks + 5; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x4704, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x4705, (UINT8)val); 
    PC = 0x6974; JUMP; // sstep
case 0x6974:
                                                     mon("         DECA                          ; 6974: 4A            \n");
    val = (UINT8)A; 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x6975; JUMP; // sstep
case 0x6975:
                                                     mon("         BGT   $6965                   ; 6975: 2E EE         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x6965; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    // End of function sub_692D
    PC = 0x6977; JUMP; // sstep
case 0x6977:
                                                     mon("         RTS                           ; 6977: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6978:
                                                     mon("L6978    LDD   #$00                    ; 6978: CC 00 00      \n"); // Some trench calculation
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x697B; JUMP; // sstep
case 0x697B:
                                                     mon("         SUBD  $5000                   ; 697B: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x697E; JUMP; // sstep
case 0x697E:
                                                     mon("         STD   $5000                   ; 697E: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6981; JUMP; // sstep
case 0x6981:
                                                     mon("         LDD   #$00                    ; 6981: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6984; JUMP; // sstep
case 0x6984:
                                                     mon("         SUBD  $5002                   ; 6984: B3 50 02      \n"); // Math result Y
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5002)<<8; 
    ea = ea | rd_mem(0x5003); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6987; JUMP; // sstep
case 0x6987:
                                                     mon("         STD   $5002                   ; 6987: FD 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5002, A); // Care needed with I/O space and word fetches
    wr_mem(0x5003, B); 
    PC = 0x698A; JUMP; // sstep
case 0x698A:
                                                     mon("         LDD   #$00                    ; 698A: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x698D; JUMP; // sstep
case 0x698D:
                                                     mon("         SUBD  $5004                   ; 698D: B3 50 04      \n"); // Math result Z
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5004)<<8; 
    ea = ea | rd_mem(0x5005); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6990; JUMP; // sstep
case 0x6990:
                                                     mon("         STD   $5004                   ; 6990: FD 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5004, A); // Care needed with I/O space and word fetches
    wr_mem(0x5005, B); 
    PC = 0x6993; JUMP; // sstep
case 0x6993:
                                                     mon("         LDD   #$01C0                  ; 6993: CC 01 C0      \n"); // Point BIC to Math RAM $5E00
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0xc0; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6996; JUMP; // sstep
case 0x6996:
                                                     mon("         STD   $4701                   ; 6996: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x6999; JUMP; // sstep
case 0x6999:
                                                     mon("         LDD   $5DF6                   ; 6999: FC 5D F6      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5df6); // Care needed with I/O space and word fetches
    B = rd_mem(0x5df7); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x699C; JUMP; // sstep
case 0x699C:
                                                     mon("         SUBD  $5000                   ; 699C: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x699F; JUMP; // sstep
case 0x699F:
                                                     mon("         STD   $4704                   ; 699F: FD 47 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x69A2; JUMP; // sstep
case 0x69A2:
                                                     mon("         LDA   #$B0                    ; 69A2: 86 B0         \n"); // XT Reg0C = [BIC,3] - Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0xb0; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69A4; JUMP; // sstep
case 0x69A4:
                                                     mon("         STA   $4700                   ; 69A4: B7 47 00      \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x69A7; JUMP; // sstep
case 0x69A7:
                                                     mon("         LDX   #$7644                  ; 69A7: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69AA; JUMP; // sstep
case 0x69AA:
                                                     mon("         LDB   <$DC                    ; 69AA: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69AC; JUMP; // sstep
case 0x69AC:
                                                     mon("         LDA   B,X                     ; 69AC: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69AE; JUMP; // sstep
case 0x69AE:
                                                     mon("         LDB   #$AE                    ; 69AE: C6 AE         \n"); // [BIC,2] = ([BIC,0] - Reg01) x (YT), [BIC,3] = ([BIC,1] - Reg02) x (YT), BIC++, XT = [BIC,3] - Reg00, BIC++
    clockticks = clockticks + 2; 
    val = (UINT8)0xae; 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69B0; JUMP; // sstep
case 0x69B0:
                                                     mon("L69B0    LDU   $4700                   ; 69B0: FE 47 00      \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x4700)<<8; 
    ea = ea | rd_mem(0x4701); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x69B3; JUMP; // sstep
case 0x69B3:
                                                     mon("         CMPU  #$0100                  ; 69B3: 11 83 01 00   \n");
    clockticks = clockticks + 5; 
    val = U; 
    arg = 0x0100; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x69B7; JUMP; // sstep
case 0x69B7:
                                                     mon("         BGT   $69BC                   ; 69B7: 2E 03         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x69bc; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x69B9; JUMP; // sstep
case 0x69B9:
                                                     mon("         LDU   #$7FFF                  ; 69B9: CE 7F FF      \n");
    clockticks = clockticks + 3; 
    U = 0x7fff; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x69BC; JUMP; // sstep
case 0x69BC:
                                                     mon("L69BC    LDX   $5018                   ; 69BC: BE 50 18      \n"); // XT
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5018)<<8; 
    ea = ea | rd_mem(0x5019); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69BF; JUMP; // sstep
case 0x69BF:
                                                     mon("         STU   $501A                   ; 69BF: FF 50 1A      \n"); // YT
    clockticks = clockticks + 5; 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x501a, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x501b, (UINT8)val); 
    PC = 0x69C2; JUMP; // sstep
case 0x69C2:
                                                     mon("         STB   $4700                   ; 69C2: F7 47 00      \n");
    clockticks = clockticks + 5; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x69C5; JUMP; // sstep
case 0x69C5:
                                                     mon("         STX   $4704                   ; 69C5: BF 47 04      \n");
    clockticks = clockticks + 5; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x4704, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x4705, (UINT8)val); 
    PC = 0x69C8; JUMP; // sstep
case 0x69C8:
                                                     mon("         DECA                          ; 69C8: 4A            \n");
    val = (UINT8)A; 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x69C9; JUMP; // sstep
case 0x69C9:
                                                     mon("         BGT   $69B0                   ; 69C9: 2E E5         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x69b0; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x69CB; JUMP; // sstep
case 0x69CB:
                                                     mon("         LDX   #$7644                  ; 69CB: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69CE; JUMP; // sstep
case 0x69CE:
                                                     mon("         LDB   <$DC                    ; 69CE: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69D0; JUMP; // sstep
case 0x69D0:
                                                     mon("         LDA   B,X                     ; 69D0: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x69D2; JUMP; // sstep
case 0x69D2:
                                                     mon("         LDU   #$5E0C                  ; 69D2: CE 5E 0C      \n");
    clockticks = clockticks + 3; 
    U = 0x5e0c; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x69D5; JUMP; // sstep
case 0x69D5:
                                                     mon("L69D5    LDX   ,U                      ; 69D5: AE C4         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(U)<<8; 
    ea = ea | rd_mem((UINT16)((U)+1)); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69D7; JUMP; // sstep
case 0x69D7:
                                                     mon("         CMPX  #$0216                  ; 69D7: 8C 02 16      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x0216; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x69DA; JUMP; // sstep
case 0x69DA:
                                                     mon("         BLE   $69E3                   ; 69DA: 2F 07         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x69e3; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x69DC; JUMP; // sstep
case 0x69DC:
                                                     mon("         LDX   #$0216                  ; 69DC: 8E 02 16      \n");
    clockticks = clockticks + 3; 
    X = 0x0216; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69DF; JUMP; // sstep
case 0x69DF:
                                                     mon("         STX   ,U                      ; 69DF: AF C4         \n");
    clockticks = clockticks + 4; 
    val = X; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = U; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x69E1; JUMP; // sstep
case 0x69E1:
                                                     mon("         BRA   $69ED                   ; 69E1: 20 0A         \n");
    PC = 0x69ed; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x69E3:
                                                     mon("L69E3    CMPX  #$FDEA                  ; 69E3: 8C FD EA      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0xfdea; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x69E6; JUMP; // sstep
case 0x69E6:
                                                     mon("         BGE   $69ED                   ; 69E6: 2C 05         \n");
    // temp fix to ensure flags synched
    if ((SINT8)(N^V) >= 0) {
    PC = 0x69ed; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x69E8; JUMP; // sstep
case 0x69E8:
                                                     mon("         LDX   #$FDEA                  ; 69E8: 8E FD EA      \n");
    clockticks = clockticks + 3; 
    X = 0xfdea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69EB; JUMP; // sstep
case 0x69EB:
                                                     mon("         STX   ,U                      ; 69EB: AF C4         \n");
    clockticks = clockticks + 4; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = U; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x69ED; JUMP; // sstep
case 0x69ED:
                                                     mon("L69ED    LDX   $02,U                   ; 69ED: AE 42         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(U + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(U + 0x0002))+1)); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69EF; JUMP; // sstep
case 0x69EF:
                                                     mon("         CMPX  #$02D8                  ; 69EF: 8C 02 D8      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x02d8; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x69F2; JUMP; // sstep
case 0x69F2:
                                                     mon("         BLE   $69FB                   ; 69F2: 2F 07         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x69fb; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x69F4; JUMP; // sstep
case 0x69F4:
                                                     mon("         LDX   #$02D8                  ; 69F4: 8E 02 D8      \n");
    clockticks = clockticks + 3; 
    X = 0x02d8; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x69F7; JUMP; // sstep
case 0x69F7:
                                                     mon("         STX   $02,U                   ; 69F7: AF 42         \n");
    clockticks = clockticks + 5; 
    val = X; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = (U + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x69F9; JUMP; // sstep
case 0x69F9:
                                                     mon("         BRA   $6A05                   ; 69F9: 20 0A         \n");
    PC = 0x6a05; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x69FB:
                                                     mon("L69FB    CMPX  #$FDEC                  ; 69FB: 8C FD EC      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0xfdec; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x69FE; JUMP; // sstep
case 0x69FE:
                                                     mon("         BGE   $6A05                   ; 69FE: 2C 05         \n");
    // temp fix to ensure flags synched
    if ((SINT8)(N^V) >= 0) {
    PC = 0x6a05; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A00; JUMP; // sstep
case 0x6A00:
                                                     mon("         LDX   #$FDEC                  ; 6A00: 8E FD EC      \n");
    clockticks = clockticks + 3; 
    X = 0xfdec; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A03; JUMP; // sstep
case 0x6A03:
                                                     mon("         STX   $02,U                   ; 6A03: AF 42         \n");
    clockticks = clockticks + 5; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = (U + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x6A05; JUMP; // sstep
case 0x6A05:
                                                     mon("L6A05    LEAU  $10,U                   ; 6A05: 33 C8 10      \n");
    clockticks = clockticks + 5; 
    U = (U + (SINT8)0x10); 
    PC = 0x6A08; JUMP; // sstep
case 0x6A08:
                                                     mon("         DECA                          ; 6A08: 4A            \n");
    val = (UINT8)A; 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x6A09; JUMP; // sstep
case 0x6A09:
                                                     mon("         BGT   $69D5                   ; 6A09: 2E CA         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x69d5; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    // End of function sub_6978
    PC = 0x6A0B; JUMP; // sstep
case 0x6A0B:
                                                     mon("         RTS                           ; 6A0B: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6A0C:
                                                     mon("L6A0C    LDD   #$00                    ; 6A0C: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6A0F; JUMP; // sstep
case 0x6A0F:
                                                     mon("         SUBD  $5000                   ; 6A0F: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6A12; JUMP; // sstep
case 0x6A12:
                                                     mon("         STD   $5000                   ; 6A12: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x6A15; JUMP; // sstep
case 0x6A15:
                                                     mon("         LDD   #$00                    ; 6A15: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6A18; JUMP; // sstep
case 0x6A18:
                                                     mon("         SUBD  $5002                   ; 6A18: B3 50 02      \n"); // Math result Y
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5002)<<8; 
    ea = ea | rd_mem(0x5003); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6A1B; JUMP; // sstep
case 0x6A1B:
                                                     mon("         STD   $5002                   ; 6A1B: FD 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5002, A); // Care needed with I/O space and word fetches
    wr_mem(0x5003, B); 
    PC = 0x6A1E; JUMP; // sstep
case 0x6A1E:
                                                     mon("         LDD   #$00                    ; 6A1E: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6A21; JUMP; // sstep
case 0x6A21:
                                                     mon("         SUBD  $5004                   ; 6A21: B3 50 04      \n"); // Math result Z
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5004)<<8; 
    ea = ea | rd_mem(0x5005); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6A24; JUMP; // sstep
case 0x6A24:
                                                     mon("         STD   $5004                   ; 6A24: FD 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5004, A); // Care needed with I/O space and word fetches
    wr_mem(0x5005, B); 
    PC = 0x6A27; JUMP; // sstep
case 0x6A27:
                                                     mon("         LDD   #$01C0                  ; 6A27: CC 01 C0      \n"); // Point BIC to Math RAM $5E00
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0xc0; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6A2A; JUMP; // sstep
case 0x6A2A:
                                                     mon("         STD   $4701                   ; 6A2A: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x6A2D; JUMP; // sstep
case 0x6A2D:
                                                     mon("         LDD   $5DF6                   ; 6A2D: FC 5D F6      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5df6); // Care needed with I/O space and word fetches
    B = rd_mem(0x5df7); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6A30; JUMP; // sstep
case 0x6A30:
                                                     mon("         SUBD  $5000                   ; 6A30: B3 50 00      \n"); // Math result X
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5000)<<8; 
    ea = ea | rd_mem(0x5001); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6A33; JUMP; // sstep
case 0x6A33:
                                                     mon("         STD   $4704                   ; 6A33: FD 47 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x6A36; JUMP; // sstep
case 0x6A36:
                                                     mon("         LDA   #$B0                    ; 6A36: 86 B0         \n"); // Reg0C = [BIC,3] - Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0xb0; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A38; JUMP; // sstep
case 0x6A38:
                                                     mon("         STA   $4700                   ; 6A38: B7 47 00      \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x6A3B; JUMP; // sstep
case 0x6A3B:
                                                     mon("         LDX   #$7644                  ; 6A3B: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A3E; JUMP; // sstep
case 0x6A3E:
                                                     mon("         LDB   <$DC                    ; 6A3E: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A40; JUMP; // sstep
case 0x6A40:
                                                     mon("         LDA   B,X                     ; 6A40: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A42; JUMP; // sstep
case 0x6A42:
                                                     mon("         LDB   #$AE                    ; 6A42: C6 AE         \n"); // [BIC,2] = ([BIC,0] - Reg01) x YT, [BIC,3] = ([BIC,1] - Reg02) x YT, BIC++, XT = [BIC,3] - Reg00, BIC++
    clockticks = clockticks + 2; 
    val = (UINT8)0xae; 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A44; JUMP; // sstep
case 0x6A44:
                                                     mon("L6A44    LDU   $4700                   ; 6A44: FE 47 00      \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x4700)<<8; 
    ea = ea | rd_mem(0x4701); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6A47; JUMP; // sstep
case 0x6A47:
                                                     mon("         CMPU  #$0100                  ; 6A47: 11 83 01 00   \n");
    clockticks = clockticks + 5; 
    val = U; 
    arg = 0x0100; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6A4B; JUMP; // sstep
case 0x6A4B:
                                                     mon("         BGT   $6A50                   ; 6A4B: 2E 03         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x6a50; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A4D; JUMP; // sstep
case 0x6A4D:
                                                     mon("         LDU   #$7FFF                  ; 6A4D: CE 7F FF      \n");
    clockticks = clockticks + 3; 
    U = 0x7fff; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6A50; JUMP; // sstep
case 0x6A50:
                                                     mon("L6A50    LDX   $5018                   ; 6A50: BE 50 18      \n"); // XT
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5018)<<8; 
    ea = ea | rd_mem(0x5019); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A53; JUMP; // sstep
case 0x6A53:
                                                     mon("         STU   $501A                   ; 6A53: FF 50 1A      \n"); // YT
    clockticks = clockticks + 5; 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x501a, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x501b, (UINT8)val); 
    PC = 0x6A56; JUMP; // sstep
case 0x6A56:
                                                     mon("         STB   $4700                   ; 6A56: F7 47 00      \n");
    clockticks = clockticks + 5; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4700, val); 
    PC = 0x6A59; JUMP; // sstep
case 0x6A59:
                                                     mon("         STX   $4704                   ; 6A59: BF 47 04      \n");
    clockticks = clockticks + 5; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    wr_mem(0x4704, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem(0x4705, (UINT8)val); 
    PC = 0x6A5C; JUMP; // sstep
case 0x6A5C:
                                                     mon("         DECA                          ; 6A5C: 4A            \n");
    val = (UINT8)A; 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x6A5D; JUMP; // sstep
case 0x6A5D:
                                                     mon("         BGT   $6A44                   ; 6A5D: 2E E5         \n"); // Loop until all object points done
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x6a44; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A5F; JUMP; // sstep
case 0x6A5F:
                                                     mon("         LDX   #$7644                  ; 6A5F: 8E 76 44      \n");
    clockticks = clockticks + 3; 
    X = 0x7644; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A62; JUMP; // sstep
case 0x6A62:
                                                     mon("         LDB   <$DC                    ; 6A62: D6 DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A64; JUMP; // sstep
case 0x6A64:
                                                     mon("         LDA   B,X                     ; 6A64: A6 85         \n");
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem((UINT16)(X + (SINT8)B)); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6A66; JUMP; // sstep
case 0x6A66:
                                                     mon("         LDU   #$5E0C                  ; 6A66: CE 5E 0C      \n");
    clockticks = clockticks + 3; 
    U = 0x5e0c; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6A69; JUMP; // sstep
case 0x6A69:
                                                     mon("L6A69    LDX   ,U                      ; 6A69: AE C4         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(U)<<8; 
    ea = ea | rd_mem((UINT16)((U)+1)); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A6B; JUMP; // sstep
case 0x6A6B:
                                                     mon("         CMPX  #$03FE                  ; 6A6B: 8C 03 FE      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x03fe; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6A6E; JUMP; // sstep
case 0x6A6E:
                                                     mon("         BLE   $6A77                   ; 6A6E: 2F 07         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x6a77; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A70; JUMP; // sstep
case 0x6A70:
                                                     mon("         LDX   #$03FE                  ; 6A70: 8E 03 FE      \n");
    clockticks = clockticks + 3; 
    X = 0x03fe; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A73; JUMP; // sstep
case 0x6A73:
                                                     mon("         STX   ,U                      ; 6A73: AF C4         \n");
    clockticks = clockticks + 4; 
    val = X; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = U; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x6A75; JUMP; // sstep
case 0x6A75:
                                                     mon("         BRA   $6A81                   ; 6A75: 20 0A         \n");
    PC = 0x6a81; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x6A77:
                                                     mon("L6A77    CMPX  #$FC02                  ; 6A77: 8C FC 02      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0xfc02; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6A7A; JUMP; // sstep
case 0x6A7A:
                                                     mon("         BGE   $6A81                   ; 6A7A: 2C 05         \n");
    // temp fix to ensure flags synched
    if ((SINT8)(N^V) >= 0) {
    PC = 0x6a81; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A7C; JUMP; // sstep
case 0x6A7C:
                                                     mon("         LDX   #$FC02                  ; 6A7C: 8E FC 02      \n");
    clockticks = clockticks + 3; 
    X = 0xfc02; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A7F; JUMP; // sstep
case 0x6A7F:
                                                     mon("         STX   ,U                      ; 6A7F: AF C4         \n");
    clockticks = clockticks + 4; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = U; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x6A81; JUMP; // sstep
case 0x6A81:
                                                     mon("L6A81    LDX   $02,U                   ; 6A81: AE 42         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(U + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(U + 0x0002))+1)); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A83; JUMP; // sstep
case 0x6A83:
                                                     mon("         CMPX  #$04C0                  ; 6A83: 8C 04 C0      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x04c0; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6A86; JUMP; // sstep
case 0x6A86:
                                                     mon("         BLE   $6A8F                   ; 6A86: 2F 07         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) <  0) || (!Z)) {
    PC = 0x6a8f; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A88; JUMP; // sstep
case 0x6A88:
                                                     mon("         LDX   #$04C0                  ; 6A88: 8E 04 C0      \n");
    clockticks = clockticks + 3; 
    X = 0x04c0; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A8B; JUMP; // sstep
case 0x6A8B:
                                                     mon("         STX   $02,U                   ; 6A8B: AF 42         \n");
    clockticks = clockticks + 5; 
    val = X; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = (U + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x6A8D; JUMP; // sstep
case 0x6A8D:
                                                     mon("         BRA   $6A99                   ; 6A8D: 20 0A         \n");
    PC = 0x6a99; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x6A8F:
                                                     mon("L6A8F    CMPX  #$FC04                  ; 6A8F: 8C FC 04      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0xfc04; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x6A92; JUMP; // sstep
case 0x6A92:
                                                     mon("         BGE   $6A99                   ; 6A92: 2C 05         \n");
    // temp fix to ensure flags synched
    if ((SINT8)(N^V) >= 0) {
    PC = 0x6a99; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6A94; JUMP; // sstep
case 0x6A94:
                                                     mon("         LDX   #$FC04                  ; 6A94: 8E FC 04      \n");
    clockticks = clockticks + 3; 
    X = 0xfc04; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6A97; JUMP; // sstep
case 0x6A97:
                                                     mon("         STX   $02,U                   ; 6A97: AF 42         \n");
    clockticks = clockticks + 5; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = (U + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x6A99; JUMP; // sstep
case 0x6A99:
                                                     mon("L6A99    LEAU  $10,U                   ; 6A99: 33 C8 10      \n");
    clockticks = clockticks + 5; 
    U = (U + (SINT8)0x10); 
    PC = 0x6A9C; JUMP; // sstep
case 0x6A9C:
                                                     mon("         DECA                          ; 6A9C: 4A            \n");
    val = (UINT8)A; 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    A = res; 
    clockticks = clockticks + 2; 
    PC = 0x6A9D; JUMP; // sstep
case 0x6A9D:
                                                     mon("         BGT   $6A69                   ; 6A9D: 2E CA         \n");
    // temp fix to ensure flags synched
    if (((SINT8)(N^V) >= 0) && Z) {
    PC = 0x6a69; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    // End of function sub_6A0C
    PC = 0x6A9F; JUMP; // sstep
case 0x6A9F:
                                                     mon("         RTS                           ; 6A9F: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6AA0:
                                                     mon("L6AA0    LDX   #$7610                  ; 6AA0: 8E 76 10      \n");
    clockticks = clockticks + 3; 
    X = 0x7610; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x6AA3; JUMP; // sstep
case 0x6AA3:
                                                     mon("         LDB   <$DC                    ; 6AA3: D6 DC         \n"); // Get object selected
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0xdc); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6AA5; JUMP; // sstep
case 0x6AA5:
                                                     mon("         ASLB                          ; 6AA5: 58            \n");
    val = (UINT8)B; 
    res = val << 1; 
/**/C = res & 0x100; 
    res = (UINT8)res; 
/**/Z = res; 
/**/N = res; 
/**/V = val ^ res; 
    B = res; 
    clockticks = clockticks + 2; 
    PC = 0x6AA6; JUMP; // sstep
case 0x6AA6:
                                                     mon("         LDU   B,X                     ; 6AA6: EE 85         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + (SINT8)B))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + (SINT8)B))+1)); 
    U = ea; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x6AA8; JUMP; // sstep
case 0x6AA8:
                                                     mon("         LDB   ,U+                     ; 6AA8: E6 C0         \n");
    clockticks = clockticks + 6; 
    val = (UINT8)rd_mem(U); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    U = U + 1; 
    PC = 0x6AAA; JUMP; // sstep
case 0x6AAA:
                                                     mon("         CMPB  #$01                    ; 6AAA: C1 01         \n"); // Check that start of function has illegal $01 instruction byte. Why??
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    arg = 0x01; 
    res = val - (UINT8)arg; 
    C = res & 0x100; 
    Z = (UINT8)res; 
    N = (UINT8)res; 
    V = (UINT8)((val ^ arg) & (val ^ res)); 
    PC = 0x6AAC; JUMP; // sstep
case 0x6AAC:
                                                     mon("         BEQ   $6AAF                   ; 6AAC: 27 01         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x6aaf; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x6AAE; JUMP; // sstep
case 0x6AAE:
                                                     mon("         SWI                           ; 6AAE: 3F            \n");
    clockticks = clockticks + 19; 
    S = S - 1; 
    wr_mem(S, 0xaf); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x6a); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, U); 
    S = S - 1; 
    wr_mem(S, U >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, Y); 
    S = S - 1; 
    wr_mem(S, Y >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, X); 
    S = S - 1; 
    wr_mem(S, X >> 8); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, (DP >> 8)); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, B); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, A); 
    clockticks = clockticks + 1; 
    simplify_flags();
    CC = (((((((((((((E<<1) | F)<<1) | H)<<1) |I)<<1) | N)<<1) | Z)<<1) | V)<<1) | C; // Placeholder for now
    restore_flags();
    S = S - 1; 
    wr_mem(S, CC); 
    clockticks = clockticks + 1; 
    PC = (rd_mem(0xfffa)<<8)|rd_mem(0xfffb); 
    JUMP;
    // End of function sub_6AA0
    // ---------------------------------------------------------------------------
  case 0x6AAF:
                                                     mon("L6AAF    JMP   ,U                      ; 6AAF: 6E C4         \n");
    clockticks = clockticks + 1; 
    clockticks = clockticks + 4; 
    PC = U; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6C1C:
                                                     mon("L6C1C    LDA   #$5E                    ; 6C1C: 86 5E         \n"); // Draws bunkers before exploded
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6C1E; JUMP; // sstep
case 0x6C1E:
                                                     mon("         TFR   A,DP                    ; 6C1E: 1F 8B         \n"); // Change zero page to Math RAM
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x6C20; JUMP; // sstep
case 0x6C20:
                                                     mon("         LDD   <$0E                    ; 6C20: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C22; JUMP; // sstep
case 0x6C22:
                                                     mon("         ADDD  #$FF98                  ; 6C22: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x6C25; JUMP; // sstep
case 0x6C25:
                                                     mon("         ANDA  #$1F                    ; 6C25: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C27; JUMP; // sstep
case 0x6C27:
                                                     mon("         STD   ,Y                      ; 6C27: ED A4         \n"); // Y points to vector RAM
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C29; JUMP; // sstep
case 0x6C29:
                                                     mon("         LDD   <$0C                    ; 6C29: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C2B; JUMP; // sstep
case 0x6C2B:
                                                     mon("         ANDA  #$1F                    ; 6C2B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C2D; JUMP; // sstep
case 0x6C2D:
                                                     mon("         STD   $02,Y                   ; 6C2D: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C2F; JUMP; // sstep
case 0x6C2F:
                                                     mon("         LDD   <$04                    ; 6C2F: DC 04         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x04); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x05); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C31; JUMP; // sstep
case 0x6C31:
                                                     mon("         STD   $04,Y                   ; 6C31: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C33; JUMP; // sstep
case 0x6C33:
                                                     mon("         LDD   <$00                    ; 6C33: DC 00         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x00); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x01); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C35; JUMP; // sstep
case 0x6C35:
                                                     mon("         STD   $06,Y                   ; 6C35: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C37; JUMP; // sstep
case 0x6C37:
                                                     mon("         LDD   <$1E                    ; 6C37: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C39; JUMP; // sstep
case 0x6C39:
                                                     mon("         SUBD  <$0E                    ; 6C39: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C3B; JUMP; // sstep
case 0x6C3B:
                                                     mon("         ANDA  #$1F                    ; 6C3B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C3D; JUMP; // sstep
case 0x6C3D:
                                                     mon("         STD   $08,Y                   ; 6C3D: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C3F; JUMP; // sstep
case 0x6C3F:
                                                     mon("         LDD   <$1C                    ; 6C3F: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C41; JUMP; // sstep
case 0x6C41:
                                                     mon("         SUBD  <$0C                    ; 6C41: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C43; JUMP; // sstep
case 0x6C43:
                                                     mon("         ANDA  #$1F                    ; 6C43: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C45; JUMP; // sstep
case 0x6C45:
                                                     mon("         STD   $0A,Y                   ; 6C45: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C47; JUMP; // sstep
case 0x6C47:
                                                     mon("         LDD   <$2E                    ; 6C47: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C49; JUMP; // sstep
case 0x6C49:
                                                     mon("         SUBD  <$1E                    ; 6C49: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C4B; JUMP; // sstep
case 0x6C4B:
                                                     mon("         ANDA  #$1F                    ; 6C4B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C4D; JUMP; // sstep
case 0x6C4D:
                                                     mon("         STD   $0C,Y                   ; 6C4D: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C4F; JUMP; // sstep
case 0x6C4F:
                                                     mon("         LDD   <$2C                    ; 6C4F: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C51; JUMP; // sstep
case 0x6C51:
                                                     mon("         SUBD  <$1C                    ; 6C51: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C53; JUMP; // sstep
case 0x6C53:
                                                     mon("         ORA   #$E0                    ; 6C53: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C55; JUMP; // sstep
case 0x6C55:
                                                     mon("         STD   $0E,Y                   ; 6C55: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C57; JUMP; // sstep
case 0x6C57:
                                                     mon("         LDD   <$EE                    ; 6C57: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C59; JUMP; // sstep
case 0x6C59:
                                                     mon("         SUBD  <$2E                    ; 6C59: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C5B; JUMP; // sstep
case 0x6C5B:
                                                     mon("         ANDA  #$1F                    ; 6C5B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C5D; JUMP; // sstep
case 0x6C5D:
                                                     mon("         STD   $10,Y                   ; 6C5D: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C60; JUMP; // sstep
case 0x6C60:
                                                     mon("         LDD   <$EC                    ; 6C60: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C62; JUMP; // sstep
case 0x6C62:
                                                     mon("         SUBD  <$2C                    ; 6C62: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C64; JUMP; // sstep
case 0x6C64:
                                                     mon("         ORA   #$E0                    ; 6C64: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C66; JUMP; // sstep
case 0x6C66:
                                                     mon("         STD   $12,Y                   ; 6C66: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C69; JUMP; // sstep
case 0x6C69:
                                                     mon("         LDD   <$DE                    ; 6C69: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C6B; JUMP; // sstep
case 0x6C6B:
                                                     mon("         SUBD  <$EE                    ; 6C6B: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C6D; JUMP; // sstep
case 0x6C6D:
                                                     mon("         ANDA  #$1F                    ; 6C6D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C6F; JUMP; // sstep
case 0x6C6F:
                                                     mon("         STD   $14,Y                   ; 6C6F: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C72; JUMP; // sstep
case 0x6C72:
                                                     mon("         LDD   <$DC                    ; 6C72: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C74; JUMP; // sstep
case 0x6C74:
                                                     mon("         SUBD  <$EC                    ; 6C74: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C76; JUMP; // sstep
case 0x6C76:
                                                     mon("         ORA   #$E0                    ; 6C76: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C78; JUMP; // sstep
case 0x6C78:
                                                     mon("         STD   $16,Y                   ; 6C78: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C7B; JUMP; // sstep
case 0x6C7B:
                                                     mon("         LDD   <$1E                    ; 6C7B: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C7D; JUMP; // sstep
case 0x6C7D:
                                                     mon("         SUBD  <$DE                    ; 6C7D: 93 DE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xde)<<8; 
    ea = ea | rd_mem(DP|0xdf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C7F; JUMP; // sstep
case 0x6C7F:
                                                     mon("         ANDA  #$1F                    ; 6C7F: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C81; JUMP; // sstep
case 0x6C81:
                                                     mon("         STD   $18,Y                   ; 6C81: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C84; JUMP; // sstep
case 0x6C84:
                                                     mon("         LDD   <$1C                    ; 6C84: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C86; JUMP; // sstep
case 0x6C86:
                                                     mon("         SUBD  <$DC                    ; 6C86: 93 DC         \n"); // Selected object model
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xdc)<<8; 
    ea = ea | rd_mem(DP|0xdd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C88; JUMP; // sstep
case 0x6C88:
                                                     mon("         ORA   #$E0                    ; 6C88: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C8A; JUMP; // sstep
case 0x6C8A:
                                                     mon("         STD   $1A,Y                   ; 6C8A: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C8D; JUMP; // sstep
case 0x6C8D:
                                                     mon("         LDD   <$3E                    ; 6C8D: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C8F; JUMP; // sstep
case 0x6C8F:
                                                     mon("         SUBD  <$1E                    ; 6C8F: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C91; JUMP; // sstep
case 0x6C91:
                                                     mon("         ANDA  #$1F                    ; 6C91: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C93; JUMP; // sstep
case 0x6C93:
                                                     mon("         STD   $1C,Y                   ; 6C93: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C96; JUMP; // sstep
case 0x6C96:
                                                     mon("         LDD   <$3C                    ; 6C96: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6C98; JUMP; // sstep
case 0x6C98:
                                                     mon("         SUBD  <$1C                    ; 6C98: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6C9A; JUMP; // sstep
case 0x6C9A:
                                                     mon("         ORA   #$E0                    ; 6C9A: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6C9C; JUMP; // sstep
case 0x6C9C:
                                                     mon("         STD   $1E,Y                   ; 6C9C: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6C9F; JUMP; // sstep
case 0x6C9F:
                                                     mon("         LDD   <$FE                    ; 6C9F: DC FE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xff); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CA1; JUMP; // sstep
case 0x6CA1:
                                                     mon("         SUBD  <$3E                    ; 6CA1: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CA3; JUMP; // sstep
case 0x6CA3:
                                                     mon("         ANDA  #$1F                    ; 6CA3: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CA5; JUMP; // sstep
case 0x6CA5:
                                                     mon("         STD   $20,Y                   ; 6CA5: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CA8; JUMP; // sstep
case 0x6CA8:
                                                     mon("         LDD   <$FC                    ; 6CA8: DC FC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xfd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CAA; JUMP; // sstep
case 0x6CAA:
                                                     mon("         SUBD  <$3C                    ; 6CAA: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CAC; JUMP; // sstep
case 0x6CAC:
                                                     mon("         ORA   #$E0                    ; 6CAC: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CAE; JUMP; // sstep
case 0x6CAE:
                                                     mon("         STD   $22,Y                   ; 6CAE: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CB1; JUMP; // sstep
case 0x6CB1:
                                                     mon("         LDD   <$DE                    ; 6CB1: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CB3; JUMP; // sstep
case 0x6CB3:
                                                     mon("         SUBD  <$FE                    ; 6CB3: 93 FE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfe)<<8; 
    ea = ea | rd_mem(DP|0xff); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CB5; JUMP; // sstep
case 0x6CB5:
                                                     mon("         ANDA  #$1F                    ; 6CB5: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CB7; JUMP; // sstep
case 0x6CB7:
                                                     mon("         STD   $24,Y                   ; 6CB7: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CBA; JUMP; // sstep
case 0x6CBA:
                                                     mon("         LDD   <$DC                    ; 6CBA: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CBC; JUMP; // sstep
case 0x6CBC:
                                                     mon("         SUBD  <$FC                    ; 6CBC: 93 FC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfc)<<8; 
    ea = ea | rd_mem(DP|0xfd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CBE; JUMP; // sstep
case 0x6CBE:
                                                     mon("         ORA   #$E0                    ; 6CBE: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CC0; JUMP; // sstep
case 0x6CC0:
                                                     mon("         STD   $26,Y                   ; 6CC0: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CC3; JUMP; // sstep
case 0x6CC3:
                                                     mon("         LDD   <$EE                    ; 6CC3: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CC5; JUMP; // sstep
case 0x6CC5:
                                                     mon("         SUBD  <$DE                    ; 6CC5: 93 DE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xde)<<8; 
    ea = ea | rd_mem(DP|0xdf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CC7; JUMP; // sstep
case 0x6CC7:
                                                     mon("         ANDA  #$1F                    ; 6CC7: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CC9; JUMP; // sstep
case 0x6CC9:
                                                     mon("         STD   $28,Y                   ; 6CC9: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CCC; JUMP; // sstep
case 0x6CCC:
                                                     mon("         LDD   <$EC                    ; 6CCC: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CCE; JUMP; // sstep
case 0x6CCE:
                                                     mon("         SUBD  <$DC                    ; 6CCE: 93 DC         \n"); // Selected object model
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xdc)<<8; 
    ea = ea | rd_mem(DP|0xdd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CD0; JUMP; // sstep
case 0x6CD0:
                                                     mon("         ANDA  #$1F                    ; 6CD0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CD2; JUMP; // sstep
case 0x6CD2:
                                                     mon("         STD   $2A,Y                   ; 6CD2: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CD5; JUMP; // sstep
case 0x6CD5:
                                                     mon("         LDD   <$FE                    ; 6CD5: DC FE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xff); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CD7; JUMP; // sstep
case 0x6CD7:
                                                     mon("         SUBD  <$EE                    ; 6CD7: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CD9; JUMP; // sstep
case 0x6CD9:
                                                     mon("         ANDA  #$1F                    ; 6CD9: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CDB; JUMP; // sstep
case 0x6CDB:
                                                     mon("         STD   $2C,Y                   ; 6CDB: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CDE; JUMP; // sstep
case 0x6CDE:
                                                     mon("         LDD   <$FC                    ; 6CDE: DC FC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xfd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CE0; JUMP; // sstep
case 0x6CE0:
                                                     mon("         SUBD  <$EC                    ; 6CE0: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6CE2; JUMP; // sstep
case 0x6CE2:
                                                     mon("         ORA   #$E0                    ; 6CE2: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6CE4; JUMP; // sstep
case 0x6CE4:
                                                     mon("         STD   $2E,Y                   ; 6CE4: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CE7; JUMP; // sstep
case 0x6CE7:
                                                     mon("         LDD   #$7200                  ; 6CE7: CC 72 00      \n"); // Insert Vector SCAL 2,00 instruction
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CEA; JUMP; // sstep
case 0x6CEA:
                                                     mon("         STD   $30,Y                   ; 6CEA: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CED; JUMP; // sstep
case 0x6CED:
                                                     mon("         LDD   #$8040                  ; 6CED: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6CF0; JUMP; // sstep
case 0x6CF0:
                                                     mon("         STD   $32,Y                   ; 6CF0: ED A8 32      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x32); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6CF3; JUMP; // sstep
case 0x6CF3:
                                                     mon("         LEAY  $34,Y                   ; 6CF3: 31 A8 34      \n"); // Increment vector RAM pointer by 52 bytes for bunker vector data
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x34); 
/**/Z = Y; 
    PC = 0x6CF6; JUMP; // sstep
case 0x6CF6:
                                                     mon("         LDA   #$48                    ; 6CF6: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6CF8; JUMP; // sstep
case 0x6CF8:
                                                     mon("         TFR   A,DP                    ; 6CF8: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_6C1C
    // ---------------------------------------------------------------------------
    PC = 0x6CFA; JUMP; // sstep
case 0x6CFA:
                                                     mon("         RTS                           ; 6CFA: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6CFC:
                                                     mon("L6CFC    LDA   #$5E                    ; 6CFC: 86 5E         \n"); // Draws towers before top exploded
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6CFE; JUMP; // sstep
case 0x6CFE:
                                                     mon("         TFR   A,DP                    ; 6CFE: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x6D00; JUMP; // sstep
case 0x6D00:
                                                     mon("         LDD   <$0E                    ; 6D00: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D02; JUMP; // sstep
case 0x6D02:
                                                     mon("         ADDD  #$FF98                  ; 6D02: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x6D05; JUMP; // sstep
case 0x6D05:
                                                     mon("         ANDA  #$1F                    ; 6D05: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D07; JUMP; // sstep
case 0x6D07:
                                                     mon("         STD   ,Y                      ; 6D07: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D09; JUMP; // sstep
case 0x6D09:
                                                     mon("         LDD   <$0C                    ; 6D09: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D0B; JUMP; // sstep
case 0x6D0B:
                                                     mon("         ANDA  #$1F                    ; 6D0B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D0D; JUMP; // sstep
case 0x6D0D:
                                                     mon("         STD   $02,Y                   ; 6D0D: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D0F; JUMP; // sstep
case 0x6D0F:
                                                     mon("         LDD   <$04                    ; 6D0F: DC 04         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x04); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x05); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D11; JUMP; // sstep
case 0x6D11:
                                                     mon("         STD   $04,Y                   ; 6D11: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D13; JUMP; // sstep
case 0x6D13:
                                                     mon("         LDD   <$02                    ; 6D13: DC 02         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x02); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x03); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D15; JUMP; // sstep
case 0x6D15:
                                                     mon("         STD   $06,Y                   ; 6D15: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D17; JUMP; // sstep
case 0x6D17:
                                                     mon("         LDD   <$1E                    ; 6D17: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D19; JUMP; // sstep
case 0x6D19:
                                                     mon("         SUBD  <$0E                    ; 6D19: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D1B; JUMP; // sstep
case 0x6D1B:
                                                     mon("         ANDA  #$1F                    ; 6D1B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D1D; JUMP; // sstep
case 0x6D1D:
                                                     mon("         STD   $08,Y                   ; 6D1D: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D1F; JUMP; // sstep
case 0x6D1F:
                                                     mon("         LDD   <$1C                    ; 6D1F: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D21; JUMP; // sstep
case 0x6D21:
                                                     mon("         SUBD  <$0C                    ; 6D21: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D23; JUMP; // sstep
case 0x6D23:
                                                     mon("         ANDA  #$1F                    ; 6D23: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D25; JUMP; // sstep
case 0x6D25:
                                                     mon("         STD   $0A,Y                   ; 6D25: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D27; JUMP; // sstep
case 0x6D27:
                                                     mon("         LDD   <$3E                    ; 6D27: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D29; JUMP; // sstep
case 0x6D29:
                                                     mon("         SUBD  <$1E                    ; 6D29: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D2B; JUMP; // sstep
case 0x6D2B:
                                                     mon("         ANDA  #$1F                    ; 6D2B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D2D; JUMP; // sstep
case 0x6D2D:
                                                     mon("         STD   $0C,Y                   ; 6D2D: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D2F; JUMP; // sstep
case 0x6D2F:
                                                     mon("         LDD   <$3C                    ; 6D2F: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D31; JUMP; // sstep
case 0x6D31:
                                                     mon("         SUBD  <$1C                    ; 6D31: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D33; JUMP; // sstep
case 0x6D33:
                                                     mon("         ORA   #$E0                    ; 6D33: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D35; JUMP; // sstep
case 0x6D35:
                                                     mon("         STD   $0E,Y                   ; 6D35: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D37; JUMP; // sstep
case 0x6D37:
                                                     mon("         LDD   <$FE                    ; 6D37: DC FE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xff); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D39; JUMP; // sstep
case 0x6D39:
                                                     mon("         SUBD  <$3E                    ; 6D39: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D3B; JUMP; // sstep
case 0x6D3B:
                                                     mon("         ANDA  #$1F                    ; 6D3B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D3D; JUMP; // sstep
case 0x6D3D:
                                                     mon("         STD   $10,Y                   ; 6D3D: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D40; JUMP; // sstep
case 0x6D40:
                                                     mon("         LDD   <$FC                    ; 6D40: DC FC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xfd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D42; JUMP; // sstep
case 0x6D42:
                                                     mon("         SUBD  <$3C                    ; 6D42: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D44; JUMP; // sstep
case 0x6D44:
                                                     mon("         ORA   #$E0                    ; 6D44: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D46; JUMP; // sstep
case 0x6D46:
                                                     mon("         STD   $12,Y                   ; 6D46: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D49; JUMP; // sstep
case 0x6D49:
                                                     mon("         LDD   <$CE                    ; 6D49: DC CE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xce); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D4B; JUMP; // sstep
case 0x6D4B:
                                                     mon("         SUBD  <$FE                    ; 6D4B: 93 FE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfe)<<8; 
    ea = ea | rd_mem(DP|0xff); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D4D; JUMP; // sstep
case 0x6D4D:
                                                     mon("         ANDA  #$1F                    ; 6D4D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D4F; JUMP; // sstep
case 0x6D4F:
                                                     mon("         STD   $14,Y                   ; 6D4F: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D52; JUMP; // sstep
case 0x6D52:
                                                     mon("         LDD   <$CC                    ; 6D52: DC CC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xcc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D54; JUMP; // sstep
case 0x6D54:
                                                     mon("         SUBD  <$FC                    ; 6D54: 93 FC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfc)<<8; 
    ea = ea | rd_mem(DP|0xfd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D56; JUMP; // sstep
case 0x6D56:
                                                     mon("         ORA   #$E0                    ; 6D56: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D58; JUMP; // sstep
case 0x6D58:
                                                     mon("         STD   $16,Y                   ; 6D58: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D5B; JUMP; // sstep
case 0x6D5B:
                                                     mon("         LDD   <$9E                    ; 6D5B: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D5D; JUMP; // sstep
case 0x6D5D:
                                                     mon("         SUBD  <$CE                    ; 6D5D: 93 CE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xce)<<8; 
    ea = ea | rd_mem(DP|0xcf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D5F; JUMP; // sstep
case 0x6D5F:
                                                     mon("         ANDA  #$1F                    ; 6D5F: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D61; JUMP; // sstep
case 0x6D61:
                                                     mon("         STD   $18,Y                   ; 6D61: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D64; JUMP; // sstep
case 0x6D64:
                                                     mon("         LDD   <$9C                    ; 6D64: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D66; JUMP; // sstep
case 0x6D66:
                                                     mon("         SUBD  <$CC                    ; 6D66: 93 CC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xcc)<<8; 
    ea = ea | rd_mem(DP|0xcd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D68; JUMP; // sstep
case 0x6D68:
                                                     mon("         ORA   #$E0                    ; 6D68: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D6A; JUMP; // sstep
case 0x6D6A:
                                                     mon("         STD   $1A,Y                   ; 6D6A: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D6D; JUMP; // sstep
case 0x6D6D:
                                                     mon("         LDD   <$00                    ; 6D6D: DC 00         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x00); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x01); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D6F; JUMP; // sstep
case 0x6D6F:
                                                     mon("         STD   $1C,Y                   ; 6D6F: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D72; JUMP; // sstep
case 0x6D72:
                                                     mon("         LDD   <$6E                    ; 6D72: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D74; JUMP; // sstep
case 0x6D74:
                                                     mon("         SUBD  <$9E                    ; 6D74: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D76; JUMP; // sstep
case 0x6D76:
                                                     mon("         ANDA  #$1F                    ; 6D76: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D78; JUMP; // sstep
case 0x6D78:
                                                     mon("         STD   $1E,Y                   ; 6D78: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D7B; JUMP; // sstep
case 0x6D7B:
                                                     mon("         LDD   <$6C                    ; 6D7B: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D7D; JUMP; // sstep
case 0x6D7D:
                                                     mon("         SUBD  <$9C                    ; 6D7D: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D7F; JUMP; // sstep
case 0x6D7F:
                                                     mon("         ORA   #$E0                    ; 6D7F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D81; JUMP; // sstep
case 0x6D81:
                                                     mon("         STD   $20,Y                   ; 6D81: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D84; JUMP; // sstep
case 0x6D84:
                                                     mon("         LDD   <$4E                    ; 6D84: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D86; JUMP; // sstep
case 0x6D86:
                                                     mon("         SUBD  <$6E                    ; 6D86: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D88; JUMP; // sstep
case 0x6D88:
                                                     mon("         ANDA  #$1F                    ; 6D88: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D8A; JUMP; // sstep
case 0x6D8A:
                                                     mon("         STD   $22,Y                   ; 6D8A: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D8D; JUMP; // sstep
case 0x6D8D:
                                                     mon("         LDD   <$4C                    ; 6D8D: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D8F; JUMP; // sstep
case 0x6D8F:
                                                     mon("         SUBD  <$6C                    ; 6D8F: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D91; JUMP; // sstep
case 0x6D91:
                                                     mon("         ORA   #$E0                    ; 6D91: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D93; JUMP; // sstep
case 0x6D93:
                                                     mon("         STD   $24,Y                   ; 6D93: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D96; JUMP; // sstep
case 0x6D96:
                                                     mon("         LDD   <$7E                    ; 6D96: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6D98; JUMP; // sstep
case 0x6D98:
                                                     mon("         SUBD  <$4E                    ; 6D98: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6D9A; JUMP; // sstep
case 0x6D9A:
                                                     mon("         ANDA  #$1F                    ; 6D9A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6D9C; JUMP; // sstep
case 0x6D9C:
                                                     mon("         STD   $26,Y                   ; 6D9C: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6D9F; JUMP; // sstep
case 0x6D9F:
                                                     mon("         LDD   <$7C                    ; 6D9F: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DA1; JUMP; // sstep
case 0x6DA1:
                                                     mon("         SUBD  <$4C                    ; 6DA1: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DA3; JUMP; // sstep
case 0x6DA3:
                                                     mon("         ORA   #$E0                    ; 6DA3: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DA5; JUMP; // sstep
case 0x6DA5:
                                                     mon("         STD   $28,Y                   ; 6DA5: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DA8; JUMP; // sstep
case 0x6DA8:
                                                     mon("         LDD   <$02                    ; 6DA8: DC 02         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x02); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x03); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DAA; JUMP; // sstep
case 0x6DAA:
                                                     mon("         STD   $2A,Y                   ; 6DAA: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DAD; JUMP; // sstep
case 0x6DAD:
                                                     mon("         LDD   <$AE                    ; 6DAD: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DAF; JUMP; // sstep
case 0x6DAF:
                                                     mon("         SUBD  <$7E                    ; 6DAF: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DB1; JUMP; // sstep
case 0x6DB1:
                                                     mon("         ANDA  #$1F                    ; 6DB1: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DB3; JUMP; // sstep
case 0x6DB3:
                                                     mon("         STD   $2C,Y                   ; 6DB3: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DB6; JUMP; // sstep
case 0x6DB6:
                                                     mon("         LDD   <$AC                    ; 6DB6: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DB8; JUMP; // sstep
case 0x6DB8:
                                                     mon("         SUBD  <$7C                    ; 6DB8: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DBA; JUMP; // sstep
case 0x6DBA:
                                                     mon("         ORA   #$E0                    ; 6DBA: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DBC; JUMP; // sstep
case 0x6DBC:
                                                     mon("         STD   $2E,Y                   ; 6DBC: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DBF; JUMP; // sstep
case 0x6DBF:
                                                     mon("         LDD   <$DE                    ; 6DBF: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DC1; JUMP; // sstep
case 0x6DC1:
                                                     mon("         SUBD  <$AE                    ; 6DC1: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DC3; JUMP; // sstep
case 0x6DC3:
                                                     mon("         ANDA  #$1F                    ; 6DC3: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DC5; JUMP; // sstep
case 0x6DC5:
                                                     mon("         STD   $30,Y                   ; 6DC5: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DC8; JUMP; // sstep
case 0x6DC8:
                                                     mon("         LDD   <$DC                    ; 6DC8: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DCA; JUMP; // sstep
case 0x6DCA:
                                                     mon("         SUBD  <$AC                    ; 6DCA: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DCC; JUMP; // sstep
case 0x6DCC:
                                                     mon("         ORA   #$E0                    ; 6DCC: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DCE; JUMP; // sstep
case 0x6DCE:
                                                     mon("         STD   $32,Y                   ; 6DCE: ED A8 32      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x32); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DD1; JUMP; // sstep
case 0x6DD1:
                                                     mon("         LDD   <$1E                    ; 6DD1: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DD3; JUMP; // sstep
case 0x6DD3:
                                                     mon("         SUBD  <$DE                    ; 6DD3: 93 DE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xde)<<8; 
    ea = ea | rd_mem(DP|0xdf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DD5; JUMP; // sstep
case 0x6DD5:
                                                     mon("         ANDA  #$1F                    ; 6DD5: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DD7; JUMP; // sstep
case 0x6DD7:
                                                     mon("         STD   $34,Y                   ; 6DD7: ED A8 34      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x34); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DDA; JUMP; // sstep
case 0x6DDA:
                                                     mon("         LDD   <$1C                    ; 6DDA: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DDC; JUMP; // sstep
case 0x6DDC:
                                                     mon("         SUBD  <$DC                    ; 6DDC: 93 DC         \n"); // Selected object model
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xdc)<<8; 
    ea = ea | rd_mem(DP|0xdd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DDE; JUMP; // sstep
case 0x6DDE:
                                                     mon("         ORA   #$E0                    ; 6DDE: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DE0; JUMP; // sstep
case 0x6DE0:
                                                     mon("         STD   $36,Y                   ; 6DE0: ED A8 36      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x36); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DE3; JUMP; // sstep
case 0x6DE3:
                                                     mon("         LDD   <$2E                    ; 6DE3: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DE5; JUMP; // sstep
case 0x6DE5:
                                                     mon("         SUBD  <$1E                    ; 6DE5: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DE7; JUMP; // sstep
case 0x6DE7:
                                                     mon("         ANDA  #$1F                    ; 6DE7: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DE9; JUMP; // sstep
case 0x6DE9:
                                                     mon("         STD   $38,Y                   ; 6DE9: ED A8 38      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x38); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DEC; JUMP; // sstep
case 0x6DEC:
                                                     mon("         LDD   <$2C                    ; 6DEC: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DEE; JUMP; // sstep
case 0x6DEE:
                                                     mon("         SUBD  <$1C                    ; 6DEE: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DF0; JUMP; // sstep
case 0x6DF0:
                                                     mon("         ORA   #$E0                    ; 6DF0: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DF2; JUMP; // sstep
case 0x6DF2:
                                                     mon("         STD   $3A,Y                   ; 6DF2: ED A8 3A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DF5; JUMP; // sstep
case 0x6DF5:
                                                     mon("         LDD   <$EE                    ; 6DF5: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6DF7; JUMP; // sstep
case 0x6DF7:
                                                     mon("         SUBD  <$2E                    ; 6DF7: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6DF9; JUMP; // sstep
case 0x6DF9:
                                                     mon("         ANDA  #$1F                    ; 6DF9: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6DFB; JUMP; // sstep
case 0x6DFB:
                                                     mon("         STD   $3C,Y                   ; 6DFB: ED A8 3C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6DFE; JUMP; // sstep
case 0x6DFE:
                                                     mon("         LDD   <$EC                    ; 6DFE: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E00; JUMP; // sstep
case 0x6E00:
                                                     mon("         SUBD  <$2C                    ; 6E00: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E02; JUMP; // sstep
case 0x6E02:
                                                     mon("         ORA   #$E0                    ; 6E02: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E04; JUMP; // sstep
case 0x6E04:
                                                     mon("         STD   $3E,Y                   ; 6E04: ED A8 3E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E07; JUMP; // sstep
case 0x6E07:
                                                     mon("         LDD   <$BE                    ; 6E07: DC BE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E09; JUMP; // sstep
case 0x6E09:
                                                     mon("         SUBD  <$EE                    ; 6E09: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E0B; JUMP; // sstep
case 0x6E0B:
                                                     mon("         ANDA  #$1F                    ; 6E0B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E0D; JUMP; // sstep
case 0x6E0D:
                                                     mon("         STD   $40,Y                   ; 6E0D: ED A8 40      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x40); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E10; JUMP; // sstep
case 0x6E10:
                                                     mon("         LDD   <$BC                    ; 6E10: DC BC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E12; JUMP; // sstep
case 0x6E12:
                                                     mon("         SUBD  <$EC                    ; 6E12: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E14; JUMP; // sstep
case 0x6E14:
                                                     mon("         ORA   #$E0                    ; 6E14: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E16; JUMP; // sstep
case 0x6E16:
                                                     mon("         STD   $42,Y                   ; 6E16: ED A8 42      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x42); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E19; JUMP; // sstep
case 0x6E19:
                                                     mon("         LDD   <$8E                    ; 6E19: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E1B; JUMP; // sstep
case 0x6E1B:
                                                     mon("         SUBD  <$BE                    ; 6E1B: 93 BE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbe)<<8; 
    ea = ea | rd_mem(DP|0xbf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E1D; JUMP; // sstep
case 0x6E1D:
                                                     mon("         ANDA  #$1F                    ; 6E1D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E1F; JUMP; // sstep
case 0x6E1F:
                                                     mon("         STD   $44,Y                   ; 6E1F: ED A8 44      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x44); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E22; JUMP; // sstep
case 0x6E22:
                                                     mon("         LDD   <$8C                    ; 6E22: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E24; JUMP; // sstep
case 0x6E24:
                                                     mon("         SUBD  <$BC                    ; 6E24: 93 BC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbc)<<8; 
    ea = ea | rd_mem(DP|0xbd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E26; JUMP; // sstep
case 0x6E26:
                                                     mon("         ORA   #$E0                    ; 6E26: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E28; JUMP; // sstep
case 0x6E28:
                                                     mon("         STD   $46,Y                   ; 6E28: ED A8 46      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x46); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E2B; JUMP; // sstep
case 0x6E2B:
                                                     mon("         LDD   <$00                    ; 6E2B: DC 00         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x00); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x01); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E2D; JUMP; // sstep
case 0x6E2D:
                                                     mon("         STD   $48,Y                   ; 6E2D: ED A8 48      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x48); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E30; JUMP; // sstep
case 0x6E30:
                                                     mon("         LDD   <$5E                    ; 6E30: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E32; JUMP; // sstep
case 0x6E32:
                                                     mon("         SUBD  <$8E                    ; 6E32: 93 8E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8e)<<8; 
    ea = ea | rd_mem(DP|0x8f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E34; JUMP; // sstep
case 0x6E34:
                                                     mon("         ANDA  #$1F                    ; 6E34: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E36; JUMP; // sstep
case 0x6E36:
                                                     mon("         STD   $4A,Y                   ; 6E36: ED A8 4A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E39; JUMP; // sstep
case 0x6E39:
                                                     mon("         LDD   <$5C                    ; 6E39: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E3B; JUMP; // sstep
case 0x6E3B:
                                                     mon("         SUBD  <$8C                    ; 6E3B: 93 8C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8c)<<8; 
    ea = ea | rd_mem(DP|0x8d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E3D; JUMP; // sstep
case 0x6E3D:
                                                     mon("         ORA   #$E0                    ; 6E3D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E3F; JUMP; // sstep
case 0x6E3F:
                                                     mon("         STD   $4C,Y                   ; 6E3F: ED A8 4C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E42; JUMP; // sstep
case 0x6E42:
                                                     mon("         LDD   <$4E                    ; 6E42: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E44; JUMP; // sstep
case 0x6E44:
                                                     mon("         SUBD  <$5E                    ; 6E44: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E46; JUMP; // sstep
case 0x6E46:
                                                     mon("         ANDA  #$1F                    ; 6E46: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E48; JUMP; // sstep
case 0x6E48:
                                                     mon("         STD   $4E,Y                   ; 6E48: ED A8 4E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E4B; JUMP; // sstep
case 0x6E4B:
                                                     mon("         LDD   <$4C                    ; 6E4B: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E4D; JUMP; // sstep
case 0x6E4D:
                                                     mon("         SUBD  <$5C                    ; 6E4D: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E4F; JUMP; // sstep
case 0x6E4F:
                                                     mon("         ORA   #$E0                    ; 6E4F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E51; JUMP; // sstep
case 0x6E51:
                                                     mon("         STD   $50,Y                   ; 6E51: ED A8 50      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x50); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E54; JUMP; // sstep
case 0x6E54:
                                                     mon("         LDD   <$7E                    ; 6E54: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E56; JUMP; // sstep
case 0x6E56:
                                                     mon("         SUBD  <$4E                    ; 6E56: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E58; JUMP; // sstep
case 0x6E58:
                                                     mon("         ANDA  #$1F                    ; 6E58: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E5A; JUMP; // sstep
case 0x6E5A:
                                                     mon("         STD   $52,Y                   ; 6E5A: ED A8 52      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x52); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E5D; JUMP; // sstep
case 0x6E5D:
                                                     mon("         LDD   <$7C                    ; 6E5D: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E5F; JUMP; // sstep
case 0x6E5F:
                                                     mon("         SUBD  <$4C                    ; 6E5F: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E61; JUMP; // sstep
case 0x6E61:
                                                     mon("         ANDA  #$1F                    ; 6E61: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E63; JUMP; // sstep
case 0x6E63:
                                                     mon("         STD   $54,Y                   ; 6E63: ED A8 54      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x54); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E66; JUMP; // sstep
case 0x6E66:
                                                     mon("         LDD   <$9E                    ; 6E66: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E68; JUMP; // sstep
case 0x6E68:
                                                     mon("         SUBD  <$7E                    ; 6E68: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E6A; JUMP; // sstep
case 0x6E6A:
                                                     mon("         ANDA  #$1F                    ; 6E6A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E6C; JUMP; // sstep
case 0x6E6C:
                                                     mon("         STD   $56,Y                   ; 6E6C: ED A8 56      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x56); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E6F; JUMP; // sstep
case 0x6E6F:
                                                     mon("         LDD   <$9C                    ; 6E6F: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E71; JUMP; // sstep
case 0x6E71:
                                                     mon("         SUBD  <$7C                    ; 6E71: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E73; JUMP; // sstep
case 0x6E73:
                                                     mon("         ORA   #$E0                    ; 6E73: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E75; JUMP; // sstep
case 0x6E75:
                                                     mon("         STD   $58,Y                   ; 6E75: ED A8 58      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x58); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E78; JUMP; // sstep
case 0x6E78:
                                                     mon("         LDD   <$7E                    ; 6E78: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E7A; JUMP; // sstep
case 0x6E7A:
                                                     mon("         SUBD  <$9E                    ; 6E7A: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E7C; JUMP; // sstep
case 0x6E7C:
                                                     mon("         ANDA  #$1F                    ; 6E7C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E7E; JUMP; // sstep
case 0x6E7E:
                                                     mon("         STD   $5A,Y                   ; 6E7E: ED A8 5A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E81; JUMP; // sstep
case 0x6E81:
                                                     mon("         LDD   <$7C                    ; 6E81: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E83; JUMP; // sstep
case 0x6E83:
                                                     mon("         SUBD  <$9C                    ; 6E83: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E85; JUMP; // sstep
case 0x6E85:
                                                     mon("         ANDA  #$1F                    ; 6E85: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E87; JUMP; // sstep
case 0x6E87:
                                                     mon("         STD   $5C,Y                   ; 6E87: ED A8 5C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E8A; JUMP; // sstep
case 0x6E8A:
                                                     mon("         LDD   <$8E                    ; 6E8A: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E8C; JUMP; // sstep
case 0x6E8C:
                                                     mon("         SUBD  <$7E                    ; 6E8C: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E8E; JUMP; // sstep
case 0x6E8E:
                                                     mon("         ANDA  #$1F                    ; 6E8E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E90; JUMP; // sstep
case 0x6E90:
                                                     mon("         STD   $5E,Y                   ; 6E90: ED A8 5E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E93; JUMP; // sstep
case 0x6E93:
                                                     mon("         LDD   <$8C                    ; 6E93: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E95; JUMP; // sstep
case 0x6E95:
                                                     mon("         SUBD  <$7C                    ; 6E95: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6E97; JUMP; // sstep
case 0x6E97:
                                                     mon("         ORA   #$E0                    ; 6E97: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6E99; JUMP; // sstep
case 0x6E99:
                                                     mon("         STD   $60,Y                   ; 6E99: ED A8 60      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x60); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6E9C; JUMP; // sstep
case 0x6E9C:
                                                     mon("         LDD   #$7200                  ; 6E9C: CC 72 00      \n"); // Vector SCAL 2,0 instruction
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6E9F; JUMP; // sstep
case 0x6E9F:
                                                     mon("         STD   $62,Y                   ; 6E9F: ED A8 62      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x62); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EA2; JUMP; // sstep
case 0x6EA2:
                                                     mon("         LDD   #$8040                  ; 6EA2: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EA5; JUMP; // sstep
case 0x6EA5:
                                                     mon("         STD   $64,Y                   ; 6EA5: ED A8 64      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x64); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EA8; JUMP; // sstep
case 0x6EA8:
                                                     mon("         LEAY  $66,Y                   ; 6EA8: 31 A8 66      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x66); 
/**/Z = Y; 
    PC = 0x6EAB; JUMP; // sstep
case 0x6EAB:
                                                     mon("         LDA   #$48                    ; 6EAB: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6EAD; JUMP; // sstep
case 0x6EAD:
                                                     mon("         TFR   A,DP                    ; 6EAD: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_6CFC
    // ---------------------------------------------------------------------------
    PC = 0x6EAF; JUMP; // sstep
case 0x6EAF:
                                                     mon("         RTS                           ; 6EAF: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6EB1:
                                                     mon("L6EB1    LDA   #$5E                    ; 6EB1: 86 5E         \n"); // Draws tower after top exploded
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6EB3; JUMP; // sstep
case 0x6EB3:
                                                     mon("         TFR   A,DP                    ; 6EB3: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x6EB5; JUMP; // sstep
case 0x6EB5:
                                                     mon("         LDD   <$0E                    ; 6EB5: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EB7; JUMP; // sstep
case 0x6EB7:
                                                     mon("         ADDD  #$FF98                  ; 6EB7: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x6EBA; JUMP; // sstep
case 0x6EBA:
                                                     mon("         ANDA  #$1F                    ; 6EBA: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EBC; JUMP; // sstep
case 0x6EBC:
                                                     mon("         STD   ,Y                      ; 6EBC: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EBE; JUMP; // sstep
case 0x6EBE:
                                                     mon("         LDD   <$0C                    ; 6EBE: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EC0; JUMP; // sstep
case 0x6EC0:
                                                     mon("         ANDA  #$1F                    ; 6EC0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EC2; JUMP; // sstep
case 0x6EC2:
                                                     mon("         STD   $02,Y                   ; 6EC2: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EC4; JUMP; // sstep
case 0x6EC4:
                                                     mon("         LDD   <$04                    ; 6EC4: DC 04         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x04); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x05); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EC6; JUMP; // sstep
case 0x6EC6:
                                                     mon("         STD   $04,Y                   ; 6EC6: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EC8; JUMP; // sstep
case 0x6EC8:
                                                     mon("         LDD   <$02                    ; 6EC8: DC 02         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x02); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x03); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6ECA; JUMP; // sstep
case 0x6ECA:
                                                     mon("         STD   $06,Y                   ; 6ECA: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6ECC; JUMP; // sstep
case 0x6ECC:
                                                     mon("         LDD   <$1E                    ; 6ECC: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6ECE; JUMP; // sstep
case 0x6ECE:
                                                     mon("         SUBD  <$0E                    ; 6ECE: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6ED0; JUMP; // sstep
case 0x6ED0:
                                                     mon("         ANDA  #$1F                    ; 6ED0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6ED2; JUMP; // sstep
case 0x6ED2:
                                                     mon("         STD   $08,Y                   ; 6ED2: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6ED4; JUMP; // sstep
case 0x6ED4:
                                                     mon("         LDD   <$1C                    ; 6ED4: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6ED6; JUMP; // sstep
case 0x6ED6:
                                                     mon("         SUBD  <$0C                    ; 6ED6: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6ED8; JUMP; // sstep
case 0x6ED8:
                                                     mon("         ANDA  #$1F                    ; 6ED8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EDA; JUMP; // sstep
case 0x6EDA:
                                                     mon("         STD   $0A,Y                   ; 6EDA: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EDC; JUMP; // sstep
case 0x6EDC:
                                                     mon("         LDD   <$3E                    ; 6EDC: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EDE; JUMP; // sstep
case 0x6EDE:
                                                     mon("         SUBD  <$1E                    ; 6EDE: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6EE0; JUMP; // sstep
case 0x6EE0:
                                                     mon("         ANDA  #$1F                    ; 6EE0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EE2; JUMP; // sstep
case 0x6EE2:
                                                     mon("         STD   $0C,Y                   ; 6EE2: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EE4; JUMP; // sstep
case 0x6EE4:
                                                     mon("         LDD   <$3C                    ; 6EE4: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EE6; JUMP; // sstep
case 0x6EE6:
                                                     mon("         SUBD  <$1C                    ; 6EE6: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6EE8; JUMP; // sstep
case 0x6EE8:
                                                     mon("         ORA   #$E0                    ; 6EE8: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EEA; JUMP; // sstep
case 0x6EEA:
                                                     mon("         STD   $0E,Y                   ; 6EEA: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EEC; JUMP; // sstep
case 0x6EEC:
                                                     mon("         LDD   <$FE                    ; 6EEC: DC FE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xff); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EEE; JUMP; // sstep
case 0x6EEE:
                                                     mon("         SUBD  <$3E                    ; 6EEE: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6EF0; JUMP; // sstep
case 0x6EF0:
                                                     mon("         ANDA  #$1F                    ; 6EF0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EF2; JUMP; // sstep
case 0x6EF2:
                                                     mon("         STD   $10,Y                   ; 6EF2: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EF5; JUMP; // sstep
case 0x6EF5:
                                                     mon("         LDD   <$FC                    ; 6EF5: DC FC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xfc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xfd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6EF7; JUMP; // sstep
case 0x6EF7:
                                                     mon("         SUBD  <$3C                    ; 6EF7: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6EF9; JUMP; // sstep
case 0x6EF9:
                                                     mon("         ORA   #$E0                    ; 6EF9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6EFB; JUMP; // sstep
case 0x6EFB:
                                                     mon("         STD   $12,Y                   ; 6EFB: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6EFE; JUMP; // sstep
case 0x6EFE:
                                                     mon("         LDD   <$CE                    ; 6EFE: DC CE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xce); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F00; JUMP; // sstep
case 0x6F00:
                                                     mon("         SUBD  <$FE                    ; 6F00: 93 FE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfe)<<8; 
    ea = ea | rd_mem(DP|0xff); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F02; JUMP; // sstep
case 0x6F02:
                                                     mon("         ANDA  #$1F                    ; 6F02: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F04; JUMP; // sstep
case 0x6F04:
                                                     mon("         STD   $14,Y                   ; 6F04: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F07; JUMP; // sstep
case 0x6F07:
                                                     mon("         LDD   <$CC                    ; 6F07: DC CC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xcc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F09; JUMP; // sstep
case 0x6F09:
                                                     mon("         SUBD  <$FC                    ; 6F09: 93 FC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xfc)<<8; 
    ea = ea | rd_mem(DP|0xfd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F0B; JUMP; // sstep
case 0x6F0B:
                                                     mon("         ORA   #$E0                    ; 6F0B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F0D; JUMP; // sstep
case 0x6F0D:
                                                     mon("         STD   $16,Y                   ; 6F0D: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F10; JUMP; // sstep
case 0x6F10:
                                                     mon("         LDD   <$9E                    ; 6F10: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F12; JUMP; // sstep
case 0x6F12:
                                                     mon("         SUBD  <$CE                    ; 6F12: 93 CE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xce)<<8; 
    ea = ea | rd_mem(DP|0xcf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F14; JUMP; // sstep
case 0x6F14:
                                                     mon("         ANDA  #$1F                    ; 6F14: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F16; JUMP; // sstep
case 0x6F16:
                                                     mon("         STD   $18,Y                   ; 6F16: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F19; JUMP; // sstep
case 0x6F19:
                                                     mon("         LDD   <$9C                    ; 6F19: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F1B; JUMP; // sstep
case 0x6F1B:
                                                     mon("         SUBD  <$CC                    ; 6F1B: 93 CC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xcc)<<8; 
    ea = ea | rd_mem(DP|0xcd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F1D; JUMP; // sstep
case 0x6F1D:
                                                     mon("         ORA   #$E0                    ; 6F1D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F1F; JUMP; // sstep
case 0x6F1F:
                                                     mon("         STD   $1A,Y                   ; 6F1F: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F22; JUMP; // sstep
case 0x6F22:
                                                     mon("         LDD   <$7E                    ; 6F22: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F24; JUMP; // sstep
case 0x6F24:
                                                     mon("         SUBD  <$9E                    ; 6F24: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F26; JUMP; // sstep
case 0x6F26:
                                                     mon("         ANDA  #$1F                    ; 6F26: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F28; JUMP; // sstep
case 0x6F28:
                                                     mon("         STD   $1C,Y                   ; 6F28: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F2B; JUMP; // sstep
case 0x6F2B:
                                                     mon("         LDD   <$7C                    ; 6F2B: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F2D; JUMP; // sstep
case 0x6F2D:
                                                     mon("         SUBD  <$9C                    ; 6F2D: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F2F; JUMP; // sstep
case 0x6F2F:
                                                     mon("         ORA   #$E0                    ; 6F2F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F31; JUMP; // sstep
case 0x6F31:
                                                     mon("         STD   $1E,Y                   ; 6F31: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F34; JUMP; // sstep
case 0x6F34:
                                                     mon("         LDD   <$AE                    ; 6F34: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F36; JUMP; // sstep
case 0x6F36:
                                                     mon("         SUBD  <$7E                    ; 6F36: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F38; JUMP; // sstep
case 0x6F38:
                                                     mon("         ANDA  #$1F                    ; 6F38: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F3A; JUMP; // sstep
case 0x6F3A:
                                                     mon("         STD   $20,Y                   ; 6F3A: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F3D; JUMP; // sstep
case 0x6F3D:
                                                     mon("         LDD   <$AC                    ; 6F3D: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F3F; JUMP; // sstep
case 0x6F3F:
                                                     mon("         SUBD  <$7C                    ; 6F3F: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F41; JUMP; // sstep
case 0x6F41:
                                                     mon("         ORA   #$E0                    ; 6F41: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F43; JUMP; // sstep
case 0x6F43:
                                                     mon("         STD   $22,Y                   ; 6F43: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F46; JUMP; // sstep
case 0x6F46:
                                                     mon("         LDD   <$DE                    ; 6F46: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F48; JUMP; // sstep
case 0x6F48:
                                                     mon("         SUBD  <$AE                    ; 6F48: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F4A; JUMP; // sstep
case 0x6F4A:
                                                     mon("         ANDA  #$1F                    ; 6F4A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F4C; JUMP; // sstep
case 0x6F4C:
                                                     mon("         STD   $24,Y                   ; 6F4C: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F4F; JUMP; // sstep
case 0x6F4F:
                                                     mon("         LDD   <$DC                    ; 6F4F: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F51; JUMP; // sstep
case 0x6F51:
                                                     mon("         SUBD  <$AC                    ; 6F51: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F53; JUMP; // sstep
case 0x6F53:
                                                     mon("         ORA   #$E0                    ; 6F53: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F55; JUMP; // sstep
case 0x6F55:
                                                     mon("         STD   $26,Y                   ; 6F55: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F58; JUMP; // sstep
case 0x6F58:
                                                     mon("         LDD   <$1E                    ; 6F58: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F5A; JUMP; // sstep
case 0x6F5A:
                                                     mon("         SUBD  <$DE                    ; 6F5A: 93 DE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xde)<<8; 
    ea = ea | rd_mem(DP|0xdf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F5C; JUMP; // sstep
case 0x6F5C:
                                                     mon("         ANDA  #$1F                    ; 6F5C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F5E; JUMP; // sstep
case 0x6F5E:
                                                     mon("         STD   $28,Y                   ; 6F5E: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F61; JUMP; // sstep
case 0x6F61:
                                                     mon("         LDD   <$1C                    ; 6F61: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F63; JUMP; // sstep
case 0x6F63:
                                                     mon("         SUBD  <$DC                    ; 6F63: 93 DC         \n"); // Selected object model
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xdc)<<8; 
    ea = ea | rd_mem(DP|0xdd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F65; JUMP; // sstep
case 0x6F65:
                                                     mon("         ORA   #$E0                    ; 6F65: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F67; JUMP; // sstep
case 0x6F67:
                                                     mon("         STD   $2A,Y                   ; 6F67: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F6A; JUMP; // sstep
case 0x6F6A:
                                                     mon("         LDD   <$2E                    ; 6F6A: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F6C; JUMP; // sstep
case 0x6F6C:
                                                     mon("         SUBD  <$1E                    ; 6F6C: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F6E; JUMP; // sstep
case 0x6F6E:
                                                     mon("         ANDA  #$1F                    ; 6F6E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F70; JUMP; // sstep
case 0x6F70:
                                                     mon("         STD   $2C,Y                   ; 6F70: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F73; JUMP; // sstep
case 0x6F73:
                                                     mon("         LDD   <$2C                    ; 6F73: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F75; JUMP; // sstep
case 0x6F75:
                                                     mon("         SUBD  <$1C                    ; 6F75: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F77; JUMP; // sstep
case 0x6F77:
                                                     mon("         ORA   #$E0                    ; 6F77: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F79; JUMP; // sstep
case 0x6F79:
                                                     mon("         STD   $2E,Y                   ; 6F79: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F7C; JUMP; // sstep
case 0x6F7C:
                                                     mon("         LDD   <$EE                    ; 6F7C: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F7E; JUMP; // sstep
case 0x6F7E:
                                                     mon("         SUBD  <$2E                    ; 6F7E: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F80; JUMP; // sstep
case 0x6F80:
                                                     mon("         ANDA  #$1F                    ; 6F80: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F82; JUMP; // sstep
case 0x6F82:
                                                     mon("         STD   $30,Y                   ; 6F82: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F85; JUMP; // sstep
case 0x6F85:
                                                     mon("         LDD   <$EC                    ; 6F85: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F87; JUMP; // sstep
case 0x6F87:
                                                     mon("         SUBD  <$2C                    ; 6F87: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F89; JUMP; // sstep
case 0x6F89:
                                                     mon("         ORA   #$E0                    ; 6F89: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F8B; JUMP; // sstep
case 0x6F8B:
                                                     mon("         STD   $32,Y                   ; 6F8B: ED A8 32      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x32); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F8E; JUMP; // sstep
case 0x6F8E:
                                                     mon("         LDD   <$BE                    ; 6F8E: DC BE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F90; JUMP; // sstep
case 0x6F90:
                                                     mon("         SUBD  <$EE                    ; 6F90: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F92; JUMP; // sstep
case 0x6F92:
                                                     mon("         ANDA  #$1F                    ; 6F92: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F94; JUMP; // sstep
case 0x6F94:
                                                     mon("         STD   $34,Y                   ; 6F94: ED A8 34      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x34); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6F97; JUMP; // sstep
case 0x6F97:
                                                     mon("         LDD   <$BC                    ; 6F97: DC BC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6F99; JUMP; // sstep
case 0x6F99:
                                                     mon("         SUBD  <$EC                    ; 6F99: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6F9B; JUMP; // sstep
case 0x6F9B:
                                                     mon("         ORA   #$E0                    ; 6F9B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6F9D; JUMP; // sstep
case 0x6F9D:
                                                     mon("         STD   $36,Y                   ; 6F9D: ED A8 36      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x36); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FA0; JUMP; // sstep
case 0x6FA0:
                                                     mon("         LDD   <$8E                    ; 6FA0: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FA2; JUMP; // sstep
case 0x6FA2:
                                                     mon("         SUBD  <$BE                    ; 6FA2: 93 BE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbe)<<8; 
    ea = ea | rd_mem(DP|0xbf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FA4; JUMP; // sstep
case 0x6FA4:
                                                     mon("         ANDA  #$1F                    ; 6FA4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FA6; JUMP; // sstep
case 0x6FA6:
                                                     mon("         STD   $38,Y                   ; 6FA6: ED A8 38      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x38); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FA9; JUMP; // sstep
case 0x6FA9:
                                                     mon("         LDD   <$8C                    ; 6FA9: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FAB; JUMP; // sstep
case 0x6FAB:
                                                     mon("         SUBD  <$BC                    ; 6FAB: 93 BC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbc)<<8; 
    ea = ea | rd_mem(DP|0xbd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FAD; JUMP; // sstep
case 0x6FAD:
                                                     mon("         ORA   #$E0                    ; 6FAD: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FAF; JUMP; // sstep
case 0x6FAF:
                                                     mon("         STD   $3A,Y                   ; 6FAF: ED A8 3A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FB2; JUMP; // sstep
case 0x6FB2:
                                                     mon("         LDD   <$7E                    ; 6FB2: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FB4; JUMP; // sstep
case 0x6FB4:
                                                     mon("         SUBD  <$8E                    ; 6FB4: 93 8E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8e)<<8; 
    ea = ea | rd_mem(DP|0x8f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FB6; JUMP; // sstep
case 0x6FB6:
                                                     mon("         ANDA  #$1F                    ; 6FB6: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FB8; JUMP; // sstep
case 0x6FB8:
                                                     mon("         STD   $3C,Y                   ; 6FB8: ED A8 3C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FBB; JUMP; // sstep
case 0x6FBB:
                                                     mon("         LDD   <$7C                    ; 6FBB: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FBD; JUMP; // sstep
case 0x6FBD:
                                                     mon("         SUBD  <$8C                    ; 6FBD: 93 8C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8c)<<8; 
    ea = ea | rd_mem(DP|0x8d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FBF; JUMP; // sstep
case 0x6FBF:
                                                     mon("         ORA   #$E0                    ; 6FBF: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FC1; JUMP; // sstep
case 0x6FC1:
                                                     mon("         STD   $3E,Y                   ; 6FC1: ED A8 3E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FC4; JUMP; // sstep
case 0x6FC4:
                                                     mon("         LDD   #$7200                  ; 6FC4: CC 72 00      \n");
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FC7; JUMP; // sstep
case 0x6FC7:
                                                     mon("         STD   $40,Y                   ; 6FC7: ED A8 40      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x40); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FCA; JUMP; // sstep
case 0x6FCA:
                                                     mon("         LDD   #$8040                  ; 6FCA: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FCD; JUMP; // sstep
case 0x6FCD:
                                                     mon("         STD   $42,Y                   ; 6FCD: ED A8 42      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x42); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FD0; JUMP; // sstep
case 0x6FD0:
                                                     mon("         LEAY  $44,Y                   ; 6FD0: 31 A8 44      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x44); 
/**/Z = Y; 
    PC = 0x6FD3; JUMP; // sstep
case 0x6FD3:
                                                     mon("         LDA   #$48                    ; 6FD3: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x6FD5; JUMP; // sstep
case 0x6FD5:
                                                     mon("         TFR   A,DP                    ; 6FD5: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_6EB1
    // ---------------------------------------------------------------------------
    PC = 0x6FD7; JUMP; // sstep
case 0x6FD7:
                                                     mon("         RTS                           ; 6FD7: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x6FD9:
                                                     mon("L6FD9    LDA   #$5E                    ; 6FD9: 86 5E         \n"); // Draws trench turrets
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x6FDB; JUMP; // sstep
case 0x6FDB:
                                                     mon("         TFR   A,DP                    ; 6FDB: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x6FDD; JUMP; // sstep
case 0x6FDD:
                                                     mon("         LDD   <$4E                    ; 6FDD: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FDF; JUMP; // sstep
case 0x6FDF:
                                                     mon("         ADDD  #$FF98                  ; 6FDF: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x6FE2; JUMP; // sstep
case 0x6FE2:
                                                     mon("         ANDA  #$1F                    ; 6FE2: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FE4; JUMP; // sstep
case 0x6FE4:
                                                     mon("         STD   ,Y                      ; 6FE4: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FE6; JUMP; // sstep
case 0x6FE6:
                                                     mon("         LDD   <$4C                    ; 6FE6: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FE8; JUMP; // sstep
case 0x6FE8:
                                                     mon("         ANDA  #$1F                    ; 6FE8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FEA; JUMP; // sstep
case 0x6FEA:
                                                     mon("         STD   $02,Y                   ; 6FEA: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FEC; JUMP; // sstep
case 0x6FEC:
                                                     mon("         LDD   #$6480                  ; 6FEC: CC 64 80      \n");
    clockticks = clockticks + 3; 
    A = 0x64; 
    B = 0x80; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FEF; JUMP; // sstep
case 0x6FEF:
                                                     mon("         STD   $04,Y                   ; 6FEF: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FF1; JUMP; // sstep
case 0x6FF1:
                                                     mon("         LDD   <$3E                    ; 6FF1: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FF3; JUMP; // sstep
case 0x6FF3:
                                                     mon("         SUBD  <$4E                    ; 6FF3: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FF5; JUMP; // sstep
case 0x6FF5:
                                                     mon("         ANDA  #$1F                    ; 6FF5: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FF7; JUMP; // sstep
case 0x6FF7:
                                                     mon("         STD   $06,Y                   ; 6FF7: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x6FF9; JUMP; // sstep
case 0x6FF9:
                                                     mon("         LDD   <$3C                    ; 6FF9: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x6FFB; JUMP; // sstep
case 0x6FFB:
                                                     mon("         SUBD  <$4C                    ; 6FFB: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x6FFD; JUMP; // sstep
case 0x6FFD:
                                                     mon("         ORA   #$E0                    ; 6FFD: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x6FFF; JUMP; // sstep
case 0x6FFF:
                                                     mon("         STD   $08,Y                   ; 6FFF: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7001; JUMP; // sstep
case 0x7001:
                                                     mon("         LDD   <$2E                    ; 7001: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7003; JUMP; // sstep
case 0x7003:
                                                     mon("         SUBD  <$3E                    ; 7003: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7005; JUMP; // sstep
case 0x7005:
                                                     mon("         ANDA  #$1F                    ; 7005: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7007; JUMP; // sstep
case 0x7007:
                                                     mon("         STD   $0A,Y                   ; 7007: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7009; JUMP; // sstep
case 0x7009:
                                                     mon("         LDD   <$2C                    ; 7009: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x700B; JUMP; // sstep
case 0x700B:
                                                     mon("         SUBD  <$3C                    ; 700B: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x700D; JUMP; // sstep
case 0x700D:
                                                     mon("         ORA   #$E0                    ; 700D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x700F; JUMP; // sstep
case 0x700F:
                                                     mon("         STD   $0C,Y                   ; 700F: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7011; JUMP; // sstep
case 0x7011:
                                                     mon("         LDD   <$1E                    ; 7011: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7013; JUMP; // sstep
case 0x7013:
                                                     mon("         SUBD  <$2E                    ; 7013: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7015; JUMP; // sstep
case 0x7015:
                                                     mon("         ANDA  #$1F                    ; 7015: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7017; JUMP; // sstep
case 0x7017:
                                                     mon("         STD   $0E,Y                   ; 7017: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7019; JUMP; // sstep
case 0x7019:
                                                     mon("         LDD   <$1C                    ; 7019: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x701B; JUMP; // sstep
case 0x701B:
                                                     mon("         SUBD  <$2C                    ; 701B: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x701D; JUMP; // sstep
case 0x701D:
                                                     mon("         ORA   #$E0                    ; 701D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x701F; JUMP; // sstep
case 0x701F:
                                                     mon("         STD   $10,Y                   ; 701F: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7022; JUMP; // sstep
case 0x7022:
                                                     mon("         LDD   <$4E                    ; 7022: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7024; JUMP; // sstep
case 0x7024:
                                                     mon("         SUBD  <$1E                    ; 7024: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7026; JUMP; // sstep
case 0x7026:
                                                     mon("         ANDA  #$1F                    ; 7026: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7028; JUMP; // sstep
case 0x7028:
                                                     mon("         STD   $12,Y                   ; 7028: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x702B; JUMP; // sstep
case 0x702B:
                                                     mon("         LDD   <$4C                    ; 702B: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x702D; JUMP; // sstep
case 0x702D:
                                                     mon("         SUBD  <$1C                    ; 702D: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x702F; JUMP; // sstep
case 0x702F:
                                                     mon("         ORA   #$E0                    ; 702F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7031; JUMP; // sstep
case 0x7031:
                                                     mon("         STD   $14,Y                   ; 7031: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7034; JUMP; // sstep
case 0x7034:
                                                     mon("         LDD   <$9E                    ; 7034: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7036; JUMP; // sstep
case 0x7036:
                                                     mon("         SUBD  <$4E                    ; 7036: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7038; JUMP; // sstep
case 0x7038:
                                                     mon("         ANDA  #$1F                    ; 7038: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x703A; JUMP; // sstep
case 0x703A:
                                                     mon("         STD   $16,Y                   ; 703A: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x703D; JUMP; // sstep
case 0x703D:
                                                     mon("         LDD   <$9C                    ; 703D: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x703F; JUMP; // sstep
case 0x703F:
                                                     mon("         SUBD  <$4C                    ; 703F: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7041; JUMP; // sstep
case 0x7041:
                                                     mon("         ORA   #$E0                    ; 7041: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7043; JUMP; // sstep
case 0x7043:
                                                     mon("         STD   $18,Y                   ; 7043: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7046; JUMP; // sstep
case 0x7046:
                                                     mon("         LDD   <$AE                    ; 7046: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7048; JUMP; // sstep
case 0x7048:
                                                     mon("         SUBD  <$9E                    ; 7048: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x704A; JUMP; // sstep
case 0x704A:
                                                     mon("         ANDA  #$1F                    ; 704A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x704C; JUMP; // sstep
case 0x704C:
                                                     mon("         STD   $1A,Y                   ; 704C: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x704F; JUMP; // sstep
case 0x704F:
                                                     mon("         LDD   <$AC                    ; 704F: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7051; JUMP; // sstep
case 0x7051:
                                                     mon("         SUBD  <$9C                    ; 7051: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7053; JUMP; // sstep
case 0x7053:
                                                     mon("         ORA   #$E0                    ; 7053: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7055; JUMP; // sstep
case 0x7055:
                                                     mon("         STD   $1C,Y                   ; 7055: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7058; JUMP; // sstep
case 0x7058:
                                                     mon("         LDD   <$1E                    ; 7058: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x705A; JUMP; // sstep
case 0x705A:
                                                     mon("         SUBD  <$AE                    ; 705A: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x705C; JUMP; // sstep
case 0x705C:
                                                     mon("         ANDA  #$1F                    ; 705C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x705E; JUMP; // sstep
case 0x705E:
                                                     mon("         STD   $1E,Y                   ; 705E: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7061; JUMP; // sstep
case 0x7061:
                                                     mon("         LDD   <$1C                    ; 7061: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7063; JUMP; // sstep
case 0x7063:
                                                     mon("         SUBD  <$AC                    ; 7063: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7065; JUMP; // sstep
case 0x7065:
                                                     mon("         ORA   #$E0                    ; 7065: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7067; JUMP; // sstep
case 0x7067:
                                                     mon("         STD   $20,Y                   ; 7067: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x706A; JUMP; // sstep
case 0x706A:
                                                     mon("         LDD   <$AE                    ; 706A: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x706C; JUMP; // sstep
case 0x706C:
                                                     mon("         SUBD  <$1E                    ; 706C: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x706E; JUMP; // sstep
case 0x706E:
                                                     mon("         ANDA  #$1F                    ; 706E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7070; JUMP; // sstep
case 0x7070:
                                                     mon("         STD   $22,Y                   ; 7070: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7073; JUMP; // sstep
case 0x7073:
                                                     mon("         LDD   <$AC                    ; 7073: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7075; JUMP; // sstep
case 0x7075:
                                                     mon("         SUBD  <$1C                    ; 7075: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7077; JUMP; // sstep
case 0x7077:
                                                     mon("         ANDA  #$1F                    ; 7077: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7079; JUMP; // sstep
case 0x7079:
                                                     mon("         STD   $24,Y                   ; 7079: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x707C; JUMP; // sstep
case 0x707C:
                                                     mon("         LDD   <$6E                    ; 707C: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x707E; JUMP; // sstep
case 0x707E:
                                                     mon("         SUBD  <$AE                    ; 707E: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7080; JUMP; // sstep
case 0x7080:
                                                     mon("         ANDA  #$1F                    ; 7080: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7082; JUMP; // sstep
case 0x7082:
                                                     mon("         STD   $26,Y                   ; 7082: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7085; JUMP; // sstep
case 0x7085:
                                                     mon("         LDD   <$6C                    ; 7085: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7087; JUMP; // sstep
case 0x7087:
                                                     mon("         SUBD  <$AC                    ; 7087: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7089; JUMP; // sstep
case 0x7089:
                                                     mon("         ORA   #$E0                    ; 7089: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x708B; JUMP; // sstep
case 0x708B:
                                                     mon("         STD   $28,Y                   ; 708B: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x708E; JUMP; // sstep
case 0x708E:
                                                     mon("         LDD   <$2E                    ; 708E: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7090; JUMP; // sstep
case 0x7090:
                                                     mon("         SUBD  <$6E                    ; 7090: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7092; JUMP; // sstep
case 0x7092:
                                                     mon("         ANDA  #$1F                    ; 7092: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7094; JUMP; // sstep
case 0x7094:
                                                     mon("         STD   $2A,Y                   ; 7094: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7097; JUMP; // sstep
case 0x7097:
                                                     mon("         LDD   <$2C                    ; 7097: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7099; JUMP; // sstep
case 0x7099:
                                                     mon("         SUBD  <$6C                    ; 7099: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x709B; JUMP; // sstep
case 0x709B:
                                                     mon("         ORA   #$E0                    ; 709B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x709D; JUMP; // sstep
case 0x709D:
                                                     mon("         STD   $2C,Y                   ; 709D: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70A0; JUMP; // sstep
case 0x70A0:
                                                     mon("         LDD   <$3E                    ; 70A0: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70A2; JUMP; // sstep
case 0x70A2:
                                                     mon("         SUBD  <$2E                    ; 70A2: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70A4; JUMP; // sstep
case 0x70A4:
                                                     mon("         ANDA  #$1F                    ; 70A4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70A6; JUMP; // sstep
case 0x70A6:
                                                     mon("         STD   $2E,Y                   ; 70A6: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70A9; JUMP; // sstep
case 0x70A9:
                                                     mon("         LDD   <$3C                    ; 70A9: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70AB; JUMP; // sstep
case 0x70AB:
                                                     mon("         SUBD  <$2C                    ; 70AB: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70AD; JUMP; // sstep
case 0x70AD:
                                                     mon("         ANDA  #$1F                    ; 70AD: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70AF; JUMP; // sstep
case 0x70AF:
                                                     mon("         STD   $30,Y                   ; 70AF: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70B2; JUMP; // sstep
case 0x70B2:
                                                     mon("         LDD   <$7E                    ; 70B2: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70B4; JUMP; // sstep
case 0x70B4:
                                                     mon("         SUBD  <$3E                    ; 70B4: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70B6; JUMP; // sstep
case 0x70B6:
                                                     mon("         ANDA  #$1F                    ; 70B6: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70B8; JUMP; // sstep
case 0x70B8:
                                                     mon("         STD   $32,Y                   ; 70B8: ED A8 32      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x32); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70BB; JUMP; // sstep
case 0x70BB:
                                                     mon("         LDD   <$7C                    ; 70BB: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70BD; JUMP; // sstep
case 0x70BD:
                                                     mon("         SUBD  <$3C                    ; 70BD: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70BF; JUMP; // sstep
case 0x70BF:
                                                     mon("         ORA   #$E0                    ; 70BF: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70C1; JUMP; // sstep
case 0x70C1:
                                                     mon("         STD   $34,Y                   ; 70C1: ED A8 34      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x34); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70C4; JUMP; // sstep
case 0x70C4:
                                                     mon("         LDD   <$6E                    ; 70C4: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70C6; JUMP; // sstep
case 0x70C6:
                                                     mon("         SUBD  <$7E                    ; 70C6: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70C8; JUMP; // sstep
case 0x70C8:
                                                     mon("         ANDA  #$1F                    ; 70C8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70CA; JUMP; // sstep
case 0x70CA:
                                                     mon("         STD   $36,Y                   ; 70CA: ED A8 36      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x36); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70CD; JUMP; // sstep
case 0x70CD:
                                                     mon("         LDD   <$6C                    ; 70CD: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70CF; JUMP; // sstep
case 0x70CF:
                                                     mon("         SUBD  <$7C                    ; 70CF: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70D1; JUMP; // sstep
case 0x70D1:
                                                     mon("         ORA   #$E0                    ; 70D1: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70D3; JUMP; // sstep
case 0x70D3:
                                                     mon("         STD   $38,Y                   ; 70D3: ED A8 38      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x38); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70D6; JUMP; // sstep
case 0x70D6:
                                                     mon("         LDD   <$5E                    ; 70D6: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70D8; JUMP; // sstep
case 0x70D8:
                                                     mon("         SUBD  <$6E                    ; 70D8: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70DA; JUMP; // sstep
case 0x70DA:
                                                     mon("         ANDA  #$1F                    ; 70DA: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70DC; JUMP; // sstep
case 0x70DC:
                                                     mon("         STD   $3A,Y                   ; 70DC: ED A8 3A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70DF; JUMP; // sstep
case 0x70DF:
                                                     mon("         LDD   <$5C                    ; 70DF: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70E1; JUMP; // sstep
case 0x70E1:
                                                     mon("         SUBD  <$6C                    ; 70E1: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70E3; JUMP; // sstep
case 0x70E3:
                                                     mon("         ORA   #$E0                    ; 70E3: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70E5; JUMP; // sstep
case 0x70E5:
                                                     mon("         STD   $3C,Y                   ; 70E5: ED A8 3C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70E8; JUMP; // sstep
case 0x70E8:
                                                     mon("         LDD   <$8E                    ; 70E8: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70EA; JUMP; // sstep
case 0x70EA:
                                                     mon("         SUBD  <$5E                    ; 70EA: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70EC; JUMP; // sstep
case 0x70EC:
                                                     mon("         ANDA  #$1F                    ; 70EC: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70EE; JUMP; // sstep
case 0x70EE:
                                                     mon("         STD   $3E,Y                   ; 70EE: ED A8 3E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70F1; JUMP; // sstep
case 0x70F1:
                                                     mon("         LDD   <$8C                    ; 70F1: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70F3; JUMP; // sstep
case 0x70F3:
                                                     mon("         SUBD  <$5C                    ; 70F3: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70F5; JUMP; // sstep
case 0x70F5:
                                                     mon("         ORA   #$E0                    ; 70F5: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x70F7; JUMP; // sstep
case 0x70F7:
                                                     mon("         STD   $40,Y                   ; 70F7: ED A8 40      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x40); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x70FA; JUMP; // sstep
case 0x70FA:
                                                     mon("         LDD   <$7E                    ; 70FA: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x70FC; JUMP; // sstep
case 0x70FC:
                                                     mon("         SUBD  <$8E                    ; 70FC: 93 8E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8e)<<8; 
    ea = ea | rd_mem(DP|0x8f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x70FE; JUMP; // sstep
case 0x70FE:
                                                     mon("         ANDA  #$1F                    ; 70FE: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7100; JUMP; // sstep
case 0x7100:
                                                     mon("         STD   $42,Y                   ; 7100: ED A8 42      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x42); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7103; JUMP; // sstep
case 0x7103:
                                                     mon("         LDD   <$7C                    ; 7103: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7105; JUMP; // sstep
case 0x7105:
                                                     mon("         SUBD  <$8C                    ; 7105: 93 8C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8c)<<8; 
    ea = ea | rd_mem(DP|0x8d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7107; JUMP; // sstep
case 0x7107:
                                                     mon("         ORA   #$E0                    ; 7107: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7109; JUMP; // sstep
case 0x7109:
                                                     mon("         STD   $44,Y                   ; 7109: ED A8 44      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x44); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x710C; JUMP; // sstep
case 0x710C:
                                                     mon("         LDD   <$9E                    ; 710C: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x710E; JUMP; // sstep
case 0x710E:
                                                     mon("         SUBD  <$7E                    ; 710E: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7110; JUMP; // sstep
case 0x7110:
                                                     mon("         ANDA  #$1F                    ; 7110: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7112; JUMP; // sstep
case 0x7112:
                                                     mon("         STD   $46,Y                   ; 7112: ED A8 46      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x46); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7115; JUMP; // sstep
case 0x7115:
                                                     mon("         LDD   <$9C                    ; 7115: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7117; JUMP; // sstep
case 0x7117:
                                                     mon("         SUBD  <$7C                    ; 7117: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7119; JUMP; // sstep
case 0x7119:
                                                     mon("         ORA   #$E0                    ; 7119: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x711B; JUMP; // sstep
case 0x711B:
                                                     mon("         STD   $48,Y                   ; 711B: ED A8 48      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x48); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x711E; JUMP; // sstep
case 0x711E:
                                                     mon("         LDD   <$8E                    ; 711E: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7120; JUMP; // sstep
case 0x7120:
                                                     mon("         SUBD  <$9E                    ; 7120: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7122; JUMP; // sstep
case 0x7122:
                                                     mon("         ANDA  #$1F                    ; 7122: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7124; JUMP; // sstep
case 0x7124:
                                                     mon("         STD   $4A,Y                   ; 7124: ED A8 4A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7127; JUMP; // sstep
case 0x7127:
                                                     mon("         LDD   <$8C                    ; 7127: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7129; JUMP; // sstep
case 0x7129:
                                                     mon("         SUBD  <$9C                    ; 7129: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x712B; JUMP; // sstep
case 0x712B:
                                                     mon("         ORA   #$E0                    ; 712B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x712D; JUMP; // sstep
case 0x712D:
                                                     mon("         STD   $4C,Y                   ; 712D: ED A8 4C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7130; JUMP; // sstep
case 0x7130:
                                                     mon("         LDD   <$DE                    ; 7130: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7132; JUMP; // sstep
case 0x7132:
                                                     mon("         SUBD  <$8E                    ; 7132: 93 8E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8e)<<8; 
    ea = ea | rd_mem(DP|0x8f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7134; JUMP; // sstep
case 0x7134:
                                                     mon("         ANDA  #$1F                    ; 7134: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7136; JUMP; // sstep
case 0x7136:
                                                     mon("         STD   $4E,Y                   ; 7136: ED A8 4E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7139; JUMP; // sstep
case 0x7139:
                                                     mon("         LDD   <$DC                    ; 7139: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x713B; JUMP; // sstep
case 0x713B:
                                                     mon("         SUBD  <$8C                    ; 713B: 93 8C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8c)<<8; 
    ea = ea | rd_mem(DP|0x8d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x713D; JUMP; // sstep
case 0x713D:
                                                     mon("         ORA   #$E0                    ; 713D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x713F; JUMP; // sstep
case 0x713F:
                                                     mon("         STD   $50,Y                   ; 713F: ED A8 50      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x50); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7142; JUMP; // sstep
case 0x7142:
                                                     mon("         LDD   <$EE                    ; 7142: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7144; JUMP; // sstep
case 0x7144:
                                                     mon("         SUBD  <$DE                    ; 7144: 93 DE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xde)<<8; 
    ea = ea | rd_mem(DP|0xdf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7146; JUMP; // sstep
case 0x7146:
                                                     mon("         ANDA  #$1F                    ; 7146: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7148; JUMP; // sstep
case 0x7148:
                                                     mon("         STD   $52,Y                   ; 7148: ED A8 52      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x52); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x714B; JUMP; // sstep
case 0x714B:
                                                     mon("         LDD   <$EC                    ; 714B: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x714D; JUMP; // sstep
case 0x714D:
                                                     mon("         SUBD  <$DC                    ; 714D: 93 DC         \n"); // Selected object model
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xdc)<<8; 
    ea = ea | rd_mem(DP|0xdd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x714F; JUMP; // sstep
case 0x714F:
                                                     mon("         ORA   #$E0                    ; 714F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7151; JUMP; // sstep
case 0x7151:
                                                     mon("         STD   $54,Y                   ; 7151: ED A8 54      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x54); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7154; JUMP; // sstep
case 0x7154:
                                                     mon("         LDD   <$9E                    ; 7154: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7156; JUMP; // sstep
case 0x7156:
                                                     mon("         SUBD  <$EE                    ; 7156: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7158; JUMP; // sstep
case 0x7158:
                                                     mon("         ANDA  #$1F                    ; 7158: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x715A; JUMP; // sstep
case 0x715A:
                                                     mon("         STD   $56,Y                   ; 715A: ED A8 56      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x56); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x715D; JUMP; // sstep
case 0x715D:
                                                     mon("         LDD   <$9C                    ; 715D: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x715F; JUMP; // sstep
case 0x715F:
                                                     mon("         SUBD  <$EC                    ; 715F: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7161; JUMP; // sstep
case 0x7161:
                                                     mon("         ORA   #$E0                    ; 7161: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7163; JUMP; // sstep
case 0x7163:
                                                     mon("         STD   $58,Y                   ; 7163: ED A8 58      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x58); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7166; JUMP; // sstep
case 0x7166:
                                                     mon("         LDD   <$EE                    ; 7166: DC EE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xee); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xef); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7168; JUMP; // sstep
case 0x7168:
                                                     mon("         SUBD  <$9E                    ; 7168: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x716A; JUMP; // sstep
case 0x716A:
                                                     mon("         ANDA  #$1F                    ; 716A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x716C; JUMP; // sstep
case 0x716C:
                                                     mon("         STD   $5A,Y                   ; 716C: ED A8 5A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x716F; JUMP; // sstep
case 0x716F:
                                                     mon("         LDD   <$EC                    ; 716F: DC EC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xec); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xed); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7171; JUMP; // sstep
case 0x7171:
                                                     mon("         SUBD  <$9C                    ; 7171: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7173; JUMP; // sstep
case 0x7173:
                                                     mon("         ANDA  #$1F                    ; 7173: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7175; JUMP; // sstep
case 0x7175:
                                                     mon("         STD   $5C,Y                   ; 7175: ED A8 5C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7178; JUMP; // sstep
case 0x7178:
                                                     mon("         LDD   <$CE                    ; 7178: DC CE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xce); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x717A; JUMP; // sstep
case 0x717A:
                                                     mon("         SUBD  <$EE                    ; 717A: 93 EE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xee)<<8; 
    ea = ea | rd_mem(DP|0xef); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x717C; JUMP; // sstep
case 0x717C:
                                                     mon("         ANDA  #$1F                    ; 717C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x717E; JUMP; // sstep
case 0x717E:
                                                     mon("         STD   $5E,Y                   ; 717E: ED A8 5E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7181; JUMP; // sstep
case 0x7181:
                                                     mon("         LDD   <$CC                    ; 7181: DC CC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xcc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7183; JUMP; // sstep
case 0x7183:
                                                     mon("         SUBD  <$EC                    ; 7183: 93 EC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xec)<<8; 
    ea = ea | rd_mem(DP|0xed); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7185; JUMP; // sstep
case 0x7185:
                                                     mon("         ORA   #$E0                    ; 7185: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7187; JUMP; // sstep
case 0x7187:
                                                     mon("         STD   $60,Y                   ; 7187: ED A8 60      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x60); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x718A; JUMP; // sstep
case 0x718A:
                                                     mon("         LDD   <$AE                    ; 718A: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x718C; JUMP; // sstep
case 0x718C:
                                                     mon("         SUBD  <$CE                    ; 718C: 93 CE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xce)<<8; 
    ea = ea | rd_mem(DP|0xcf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x718E; JUMP; // sstep
case 0x718E:
                                                     mon("         ANDA  #$1F                    ; 718E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7190; JUMP; // sstep
case 0x7190:
                                                     mon("         STD   $62,Y                   ; 7190: ED A8 62      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x62); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7193; JUMP; // sstep
case 0x7193:
                                                     mon("         LDD   <$AC                    ; 7193: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7195; JUMP; // sstep
case 0x7195:
                                                     mon("         SUBD  <$CC                    ; 7195: 93 CC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xcc)<<8; 
    ea = ea | rd_mem(DP|0xcd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7197; JUMP; // sstep
case 0x7197:
                                                     mon("         ORA   #$E0                    ; 7197: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7199; JUMP; // sstep
case 0x7199:
                                                     mon("         STD   $64,Y                   ; 7199: ED A8 64      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x64); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x719C; JUMP; // sstep
case 0x719C:
                                                     mon("         LDD   <$5E                    ; 719C: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x719E; JUMP; // sstep
case 0x719E:
                                                     mon("         SUBD  <$AE                    ; 719E: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71A0; JUMP; // sstep
case 0x71A0:
                                                     mon("         ANDA  #$1F                    ; 71A0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71A2; JUMP; // sstep
case 0x71A2:
                                                     mon("         STD   $66,Y                   ; 71A2: ED A8 66      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x66); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71A5; JUMP; // sstep
case 0x71A5:
                                                     mon("         LDD   <$5C                    ; 71A5: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71A7; JUMP; // sstep
case 0x71A7:
                                                     mon("         SUBD  <$AC                    ; 71A7: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71A9; JUMP; // sstep
case 0x71A9:
                                                     mon("         ORA   #$E0                    ; 71A9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71AB; JUMP; // sstep
case 0x71AB:
                                                     mon("         STD   $68,Y                   ; 71AB: ED A8 68      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x68); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71AE; JUMP; // sstep
case 0x71AE:
                                                     mon("         LDD   <$BE                    ; 71AE: DC BE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71B0; JUMP; // sstep
case 0x71B0:
                                                     mon("         SUBD  <$5E                    ; 71B0: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71B2; JUMP; // sstep
case 0x71B2:
                                                     mon("         ANDA  #$1F                    ; 71B2: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71B4; JUMP; // sstep
case 0x71B4:
                                                     mon("         STD   $6A,Y                   ; 71B4: ED A8 6A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x6a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71B7; JUMP; // sstep
case 0x71B7:
                                                     mon("         LDD   <$BC                    ; 71B7: DC BC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71B9; JUMP; // sstep
case 0x71B9:
                                                     mon("         SUBD  <$5C                    ; 71B9: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71BB; JUMP; // sstep
case 0x71BB:
                                                     mon("         ORA   #$E0                    ; 71BB: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71BD; JUMP; // sstep
case 0x71BD:
                                                     mon("         STD   $6C,Y                   ; 71BD: ED A8 6C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x6c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71C0; JUMP; // sstep
case 0x71C0:
                                                     mon("         LDD   <$CE                    ; 71C0: DC CE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xce); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71C2; JUMP; // sstep
case 0x71C2:
                                                     mon("         SUBD  <$BE                    ; 71C2: 93 BE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbe)<<8; 
    ea = ea | rd_mem(DP|0xbf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71C4; JUMP; // sstep
case 0x71C4:
                                                     mon("         ANDA  #$1F                    ; 71C4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71C6; JUMP; // sstep
case 0x71C6:
                                                     mon("         STD   $6E,Y                   ; 71C6: ED A8 6E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x6e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71C9; JUMP; // sstep
case 0x71C9:
                                                     mon("         LDD   <$CC                    ; 71C9: DC CC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xcc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xcd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71CB; JUMP; // sstep
case 0x71CB:
                                                     mon("         SUBD  <$BC                    ; 71CB: 93 BC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbc)<<8; 
    ea = ea | rd_mem(DP|0xbd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71CD; JUMP; // sstep
case 0x71CD:
                                                     mon("         ORA   #$E0                    ; 71CD: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71CF; JUMP; // sstep
case 0x71CF:
                                                     mon("         STD   $70,Y                   ; 71CF: ED A8 70      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x70); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71D2; JUMP; // sstep
case 0x71D2:
                                                     mon("         LDD   <$BE                    ; 71D2: DC BE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71D4; JUMP; // sstep
case 0x71D4:
                                                     mon("         SUBD  <$CE                    ; 71D4: 93 CE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xce)<<8; 
    ea = ea | rd_mem(DP|0xcf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71D6; JUMP; // sstep
case 0x71D6:
                                                     mon("         ANDA  #$1F                    ; 71D6: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71D8; JUMP; // sstep
case 0x71D8:
                                                     mon("         STD   $72,Y                   ; 71D8: ED A8 72      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x72); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71DB; JUMP; // sstep
case 0x71DB:
                                                     mon("         LDD   <$BC                    ; 71DB: DC BC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71DD; JUMP; // sstep
case 0x71DD:
                                                     mon("         SUBD  <$CC                    ; 71DD: 93 CC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xcc)<<8; 
    ea = ea | rd_mem(DP|0xcd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71DF; JUMP; // sstep
case 0x71DF:
                                                     mon("         ANDA  #$1F                    ; 71DF: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71E1; JUMP; // sstep
case 0x71E1:
                                                     mon("         STD   $74,Y                   ; 71E1: ED A8 74      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x74); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71E4; JUMP; // sstep
case 0x71E4:
                                                     mon("         LDD   <$DE                    ; 71E4: DC DE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xde); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71E6; JUMP; // sstep
case 0x71E6:
                                                     mon("         SUBD  <$BE                    ; 71E6: 93 BE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbe)<<8; 
    ea = ea | rd_mem(DP|0xbf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71E8; JUMP; // sstep
case 0x71E8:
                                                     mon("         ANDA  #$1F                    ; 71E8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71EA; JUMP; // sstep
case 0x71EA:
                                                     mon("         STD   $76,Y                   ; 71EA: ED A8 76      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x76); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71ED; JUMP; // sstep
case 0x71ED:
                                                     mon("         LDD   <$DC                    ; 71ED: DC DC         \n"); // Selected object model
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xdc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xdd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71EF; JUMP; // sstep
case 0x71EF:
                                                     mon("         SUBD  <$BC                    ; 71EF: 93 BC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbc)<<8; 
    ea = ea | rd_mem(DP|0xbd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x71F1; JUMP; // sstep
case 0x71F1:
                                                     mon("         ORA   #$E0                    ; 71F1: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x71F3; JUMP; // sstep
case 0x71F3:
                                                     mon("         STD   $78,Y                   ; 71F3: ED A8 78      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x78); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71F6; JUMP; // sstep
case 0x71F6:
                                                     mon("         LDD   #$7200                  ; 71F6: CC 72 00      \n");
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71F9; JUMP; // sstep
case 0x71F9:
                                                     mon("         STD   $7A,Y                   ; 71F9: ED A8 7A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x7a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x71FC; JUMP; // sstep
case 0x71FC:
                                                     mon("         LDD   #$8040                  ; 71FC: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x71FF; JUMP; // sstep
case 0x71FF:
                                                     mon("         STD   $7C,Y                   ; 71FF: ED A8 7C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x7c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7202; JUMP; // sstep
case 0x7202:
                                                     mon("         LEAY  $7E,Y                   ; 7202: 31 A8 7E      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x7e); 
/**/Z = Y; 
    PC = 0x7205; JUMP; // sstep
case 0x7205:
                                                     mon("         LDA   #$48                    ; 7205: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7207; JUMP; // sstep
case 0x7207:
                                                     mon("         TFR   A,DP                    ; 7207: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_6FD9
    // ---------------------------------------------------------------------------
    PC = 0x7209; JUMP; // sstep
case 0x7209:
                                                     mon("         RTS                           ; 7209: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x720B:
                                                     mon("L720B    LDA   #$5E                    ; 720B: 86 5E         \n"); // Draws trench green squares
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x720D; JUMP; // sstep
case 0x720D:
                                                     mon("         TFR   A,DP                    ; 720D: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x720F; JUMP; // sstep
case 0x720F:
                                                     mon("         LDD   <$0E                    ; 720F: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7211; JUMP; // sstep
case 0x7211:
                                                     mon("         ADDD  #$FF98                  ; 7211: C3 FF 98      \n"); // Y axis offset for squares
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x7214; JUMP; // sstep
case 0x7214:
                                                     mon("         ANDA  #$1F                    ; 7214: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7216; JUMP; // sstep
case 0x7216:
                                                     mon("         STD   ,Y                      ; 7216: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7218; JUMP; // sstep
case 0x7218:
                                                     mon("         LDD   <$0C                    ; 7218: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x721A; JUMP; // sstep
case 0x721A:
                                                     mon("         ANDA  #$1F                    ; 721A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x721C; JUMP; // sstep
case 0x721C:
                                                     mon("         STD   $02,Y                   ; 721C: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x721E; JUMP; // sstep
case 0x721E:
                                                     mon("         LDD   #$6280                  ; 721E: CC 62 80      \n"); // Insert Vector STAT 2,80 instruction (Green)
    clockticks = clockticks + 3; 
    A = 0x62; 
    B = 0x80; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7221; JUMP; // sstep
case 0x7221:
                                                     mon("         STD   $04,Y                   ; 7221: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7223; JUMP; // sstep
case 0x7223:
                                                     mon("         LDD   <$1E                    ; 7223: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7225; JUMP; // sstep
case 0x7225:
                                                     mon("         SUBD  <$0E                    ; 7225: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7227; JUMP; // sstep
case 0x7227:
                                                     mon("         ANDA  #$1F                    ; 7227: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7229; JUMP; // sstep
case 0x7229:
                                                     mon("         STD   $06,Y                   ; 7229: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x722B; JUMP; // sstep
case 0x722B:
                                                     mon("         LDD   <$1C                    ; 722B: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x722D; JUMP; // sstep
case 0x722D:
                                                     mon("         SUBD  <$0C                    ; 722D: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x722F; JUMP; // sstep
case 0x722F:
                                                     mon("         ORA   #$E0                    ; 722F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7231; JUMP; // sstep
case 0x7231:
                                                     mon("         STD   $08,Y                   ; 7231: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7233; JUMP; // sstep
case 0x7233:
                                                     mon("         LDD   <$2E                    ; 7233: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7235; JUMP; // sstep
case 0x7235:
                                                     mon("         SUBD  <$1E                    ; 7235: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7237; JUMP; // sstep
case 0x7237:
                                                     mon("         ANDA  #$1F                    ; 7237: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7239; JUMP; // sstep
case 0x7239:
                                                     mon("         STD   $0A,Y                   ; 7239: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x723B; JUMP; // sstep
case 0x723B:
                                                     mon("         LDD   <$2C                    ; 723B: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x723D; JUMP; // sstep
case 0x723D:
                                                     mon("         SUBD  <$1C                    ; 723D: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x723F; JUMP; // sstep
case 0x723F:
                                                     mon("         ORA   #$E0                    ; 723F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7241; JUMP; // sstep
case 0x7241:
                                                     mon("         STD   $0C,Y                   ; 7241: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7243; JUMP; // sstep
case 0x7243:
                                                     mon("         LDD   <$3E                    ; 7243: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7245; JUMP; // sstep
case 0x7245:
                                                     mon("         SUBD  <$2E                    ; 7245: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7247; JUMP; // sstep
case 0x7247:
                                                     mon("         ANDA  #$1F                    ; 7247: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7249; JUMP; // sstep
case 0x7249:
                                                     mon("         STD   $0E,Y                   ; 7249: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x724B; JUMP; // sstep
case 0x724B:
                                                     mon("         LDD   <$3C                    ; 724B: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x724D; JUMP; // sstep
case 0x724D:
                                                     mon("         SUBD  <$2C                    ; 724D: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x724F; JUMP; // sstep
case 0x724F:
                                                     mon("         ORA   #$E0                    ; 724F: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7251; JUMP; // sstep
case 0x7251:
                                                     mon("         STD   $10,Y                   ; 7251: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7254; JUMP; // sstep
case 0x7254:
                                                     mon("         LDD   <$0E                    ; 7254: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7256; JUMP; // sstep
case 0x7256:
                                                     mon("         SUBD  <$3E                    ; 7256: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7258; JUMP; // sstep
case 0x7258:
                                                     mon("         ANDA  #$1F                    ; 7258: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x725A; JUMP; // sstep
case 0x725A:
                                                     mon("         STD   $12,Y                   ; 725A: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x725D; JUMP; // sstep
case 0x725D:
                                                     mon("         LDD   <$0C                    ; 725D: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x725F; JUMP; // sstep
case 0x725F:
                                                     mon("         SUBD  <$3C                    ; 725F: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7261; JUMP; // sstep
case 0x7261:
                                                     mon("         ORA   #$E0                    ; 7261: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7263; JUMP; // sstep
case 0x7263:
                                                     mon("         STD   $14,Y                   ; 7263: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7266; JUMP; // sstep
case 0x7266:
                                                     mon("         LDD   <$4E                    ; 7266: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7268; JUMP; // sstep
case 0x7268:
                                                     mon("         SUBD  <$0E                    ; 7268: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x726A; JUMP; // sstep
case 0x726A:
                                                     mon("         ANDA  #$1F                    ; 726A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x726C; JUMP; // sstep
case 0x726C:
                                                     mon("         STD   $16,Y                   ; 726C: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x726F; JUMP; // sstep
case 0x726F:
                                                     mon("         LDD   <$4C                    ; 726F: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7271; JUMP; // sstep
case 0x7271:
                                                     mon("         SUBD  <$0C                    ; 7271: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7273; JUMP; // sstep
case 0x7273:
                                                     mon("         ANDA  #$1F                    ; 7273: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7275; JUMP; // sstep
case 0x7275:
                                                     mon("         STD   $18,Y                   ; 7275: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7278; JUMP; // sstep
case 0x7278:
                                                     mon("         LDD   <$5E                    ; 7278: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x727A; JUMP; // sstep
case 0x727A:
                                                     mon("         SUBD  <$4E                    ; 727A: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x727C; JUMP; // sstep
case 0x727C:
                                                     mon("         ANDA  #$1F                    ; 727C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x727E; JUMP; // sstep
case 0x727E:
                                                     mon("         STD   $1A,Y                   ; 727E: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7281; JUMP; // sstep
case 0x7281:
                                                     mon("         LDD   <$5C                    ; 7281: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7283; JUMP; // sstep
case 0x7283:
                                                     mon("         SUBD  <$4C                    ; 7283: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7285; JUMP; // sstep
case 0x7285:
                                                     mon("         ORA   #$E0                    ; 7285: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7287; JUMP; // sstep
case 0x7287:
                                                     mon("         STD   $1C,Y                   ; 7287: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x728A; JUMP; // sstep
case 0x728A:
                                                     mon("         LDD   <$6E                    ; 728A: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x728C; JUMP; // sstep
case 0x728C:
                                                     mon("         SUBD  <$5E                    ; 728C: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x728E; JUMP; // sstep
case 0x728E:
                                                     mon("         ANDA  #$1F                    ; 728E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7290; JUMP; // sstep
case 0x7290:
                                                     mon("         STD   $1E,Y                   ; 7290: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7293; JUMP; // sstep
case 0x7293:
                                                     mon("         LDD   <$6C                    ; 7293: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7295; JUMP; // sstep
case 0x7295:
                                                     mon("         SUBD  <$5C                    ; 7295: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7297; JUMP; // sstep
case 0x7297:
                                                     mon("         ORA   #$E0                    ; 7297: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7299; JUMP; // sstep
case 0x7299:
                                                     mon("         STD   $20,Y                   ; 7299: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x729C; JUMP; // sstep
case 0x729C:
                                                     mon("         LDD   <$7E                    ; 729C: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x729E; JUMP; // sstep
case 0x729E:
                                                     mon("         SUBD  <$6E                    ; 729E: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72A0; JUMP; // sstep
case 0x72A0:
                                                     mon("         ANDA  #$1F                    ; 72A0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72A2; JUMP; // sstep
case 0x72A2:
                                                     mon("         STD   $22,Y                   ; 72A2: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72A5; JUMP; // sstep
case 0x72A5:
                                                     mon("         LDD   <$7C                    ; 72A5: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72A7; JUMP; // sstep
case 0x72A7:
                                                     mon("         SUBD  <$6C                    ; 72A7: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72A9; JUMP; // sstep
case 0x72A9:
                                                     mon("         ORA   #$E0                    ; 72A9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72AB; JUMP; // sstep
case 0x72AB:
                                                     mon("         STD   $24,Y                   ; 72AB: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72AE; JUMP; // sstep
case 0x72AE:
                                                     mon("         LDD   <$4E                    ; 72AE: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72B0; JUMP; // sstep
case 0x72B0:
                                                     mon("         SUBD  <$7E                    ; 72B0: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72B2; JUMP; // sstep
case 0x72B2:
                                                     mon("         ANDA  #$1F                    ; 72B2: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72B4; JUMP; // sstep
case 0x72B4:
                                                     mon("         STD   $26,Y                   ; 72B4: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72B7; JUMP; // sstep
case 0x72B7:
                                                     mon("         LDD   <$4C                    ; 72B7: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72B9; JUMP; // sstep
case 0x72B9:
                                                     mon("         SUBD  <$7C                    ; 72B9: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72BB; JUMP; // sstep
case 0x72BB:
                                                     mon("         ORA   #$E0                    ; 72BB: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72BD; JUMP; // sstep
case 0x72BD:
                                                     mon("         STD   $28,Y                   ; 72BD: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72C0; JUMP; // sstep
case 0x72C0:
                                                     mon("         LDD   #$7200                  ; 72C0: CC 72 00      \n");
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72C3; JUMP; // sstep
case 0x72C3:
                                                     mon("         STD   $2A,Y                   ; 72C3: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72C6; JUMP; // sstep
case 0x72C6:
                                                     mon("         LDD   #$8040                  ; 72C6: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72C9; JUMP; // sstep
case 0x72C9:
                                                     mon("         STD   $2C,Y                   ; 72C9: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72CC; JUMP; // sstep
case 0x72CC:
                                                     mon("         LEAY  $2E,Y                   ; 72CC: 31 A8 2E      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x2e); 
/**/Z = Y; 
    PC = 0x72CF; JUMP; // sstep
case 0x72CF:
                                                     mon("         LDA   #$48                    ; 72CF: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x72D1; JUMP; // sstep
case 0x72D1:
                                                     mon("         TFR   A,DP                    ; 72D1: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_720B
    // ---------------------------------------------------------------------------
    PC = 0x72D3; JUMP; // sstep
case 0x72D3:
                                                     mon("         RTS                           ; 72D3: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x72D5:
                                                     mon("L72D5    LDA   #$5E                    ; 72D5: 86 5E         \n"); // Draws trench catwalks
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x72D7; JUMP; // sstep
case 0x72D7:
                                                     mon("         TFR   A,DP                    ; 72D7: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x72D9; JUMP; // sstep
case 0x72D9:
                                                     mon("         LDD   <$1E                    ; 72D9: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72DB; JUMP; // sstep
case 0x72DB:
                                                     mon("         ADDD  #$FF98                  ; 72DB: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x72DE; JUMP; // sstep
case 0x72DE:
                                                     mon("         ANDA  #$1F                    ; 72DE: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72E0; JUMP; // sstep
case 0x72E0:
                                                     mon("         STD   ,Y                      ; 72E0: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72E2; JUMP; // sstep
case 0x72E2:
                                                     mon("         LDD   <$1C                    ; 72E2: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72E4; JUMP; // sstep
case 0x72E4:
                                                     mon("         ANDA  #$1F                    ; 72E4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72E6; JUMP; // sstep
case 0x72E6:
                                                     mon("         STD   $02,Y                   ; 72E6: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72E8; JUMP; // sstep
case 0x72E8:
                                                     mon("         LDD   <$0E                    ; 72E8: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72EA; JUMP; // sstep
case 0x72EA:
                                                     mon("         SUBD  <$1E                    ; 72EA: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72EC; JUMP; // sstep
case 0x72EC:
                                                     mon("         ANDA  #$1F                    ; 72EC: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72EE; JUMP; // sstep
case 0x72EE:
                                                     mon("         STD   $04,Y                   ; 72EE: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72F0; JUMP; // sstep
case 0x72F0:
                                                     mon("         LDD   <$0C                    ; 72F0: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72F2; JUMP; // sstep
case 0x72F2:
                                                     mon("         SUBD  <$1C                    ; 72F2: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72F4; JUMP; // sstep
case 0x72F4:
                                                     mon("         ORA   #$E0                    ; 72F4: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72F6; JUMP; // sstep
case 0x72F6:
                                                     mon("         STD   $06,Y                   ; 72F6: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x72F8; JUMP; // sstep
case 0x72F8:
                                                     mon("         LDD   <$2E                    ; 72F8: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x72FA; JUMP; // sstep
case 0x72FA:
                                                     mon("         SUBD  <$0E                    ; 72FA: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x72FC; JUMP; // sstep
case 0x72FC:
                                                     mon("         ANDA  #$1F                    ; 72FC: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x72FE; JUMP; // sstep
case 0x72FE:
                                                     mon("         STD   $08,Y                   ; 72FE: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7300; JUMP; // sstep
case 0x7300:
                                                     mon("         LDD   <$2C                    ; 7300: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7302; JUMP; // sstep
case 0x7302:
                                                     mon("         SUBD  <$0C                    ; 7302: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7304; JUMP; // sstep
case 0x7304:
                                                     mon("         ORA   #$E0                    ; 7304: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7306; JUMP; // sstep
case 0x7306:
                                                     mon("         STD   $0A,Y                   ; 7306: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7308; JUMP; // sstep
case 0x7308:
                                                     mon("         LDD   <$3E                    ; 7308: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x730A; JUMP; // sstep
case 0x730A:
                                                     mon("         SUBD  <$2E                    ; 730A: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x730C; JUMP; // sstep
case 0x730C:
                                                     mon("         ANDA  #$1F                    ; 730C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x730E; JUMP; // sstep
case 0x730E:
                                                     mon("         STD   $0C,Y                   ; 730E: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7310; JUMP; // sstep
case 0x7310:
                                                     mon("         LDD   <$3C                    ; 7310: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7312; JUMP; // sstep
case 0x7312:
                                                     mon("         SUBD  <$2C                    ; 7312: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7314; JUMP; // sstep
case 0x7314:
                                                     mon("         ORA   #$E0                    ; 7314: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7316; JUMP; // sstep
case 0x7316:
                                                     mon("         STD   $0E,Y                   ; 7316: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7318; JUMP; // sstep
case 0x7318:
                                                     mon("         LDD   <$1E                    ; 7318: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x731A; JUMP; // sstep
case 0x731A:
                                                     mon("         SUBD  <$3E                    ; 731A: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x731C; JUMP; // sstep
case 0x731C:
                                                     mon("         ANDA  #$1F                    ; 731C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x731E; JUMP; // sstep
case 0x731E:
                                                     mon("         STD   $10,Y                   ; 731E: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7321; JUMP; // sstep
case 0x7321:
                                                     mon("         LDD   <$1C                    ; 7321: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7323; JUMP; // sstep
case 0x7323:
                                                     mon("         SUBD  <$3C                    ; 7323: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7325; JUMP; // sstep
case 0x7325:
                                                     mon("         ORA   #$E0                    ; 7325: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7327; JUMP; // sstep
case 0x7327:
                                                     mon("         STD   $12,Y                   ; 7327: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x732A; JUMP; // sstep
case 0x732A:
                                                     mon("         LDD   <$5E                    ; 732A: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x732C; JUMP; // sstep
case 0x732C:
                                                     mon("         SUBD  <$1E                    ; 732C: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x732E; JUMP; // sstep
case 0x732E:
                                                     mon("         ANDA  #$1F                    ; 732E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7330; JUMP; // sstep
case 0x7330:
                                                     mon("         STD   $14,Y                   ; 7330: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7333; JUMP; // sstep
case 0x7333:
                                                     mon("         LDD   <$5C                    ; 7333: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7335; JUMP; // sstep
case 0x7335:
                                                     mon("         SUBD  <$1C                    ; 7335: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7337; JUMP; // sstep
case 0x7337:
                                                     mon("         ORA   #$E0                    ; 7337: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7339; JUMP; // sstep
case 0x7339:
                                                     mon("         STD   $16,Y                   ; 7339: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x733C; JUMP; // sstep
case 0x733C:
                                                     mon("         LDD   <$4E                    ; 733C: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x733E; JUMP; // sstep
case 0x733E:
                                                     mon("         SUBD  <$5E                    ; 733E: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7340; JUMP; // sstep
case 0x7340:
                                                     mon("         ANDA  #$1F                    ; 7340: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7342; JUMP; // sstep
case 0x7342:
                                                     mon("         STD   $18,Y                   ; 7342: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7345; JUMP; // sstep
case 0x7345:
                                                     mon("         LDD   <$4C                    ; 7345: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7347; JUMP; // sstep
case 0x7347:
                                                     mon("         SUBD  <$5C                    ; 7347: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7349; JUMP; // sstep
case 0x7349:
                                                     mon("         ORA   #$E0                    ; 7349: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x734B; JUMP; // sstep
case 0x734B:
                                                     mon("         STD   $1A,Y                   ; 734B: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x734E; JUMP; // sstep
case 0x734E:
                                                     mon("         LDD   <$0E                    ; 734E: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7350; JUMP; // sstep
case 0x7350:
                                                     mon("         SUBD  <$4E                    ; 7350: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7352; JUMP; // sstep
case 0x7352:
                                                     mon("         ANDA  #$1F                    ; 7352: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7354; JUMP; // sstep
case 0x7354:
                                                     mon("         STD   $1C,Y                   ; 7354: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7357; JUMP; // sstep
case 0x7357:
                                                     mon("         LDD   <$0C                    ; 7357: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7359; JUMP; // sstep
case 0x7359:
                                                     mon("         SUBD  <$4C                    ; 7359: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x735B; JUMP; // sstep
case 0x735B:
                                                     mon("         ORA   #$E0                    ; 735B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x735D; JUMP; // sstep
case 0x735D:
                                                     mon("         STD   $1E,Y                   ; 735D: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7360; JUMP; // sstep
case 0x7360:
                                                     mon("         LDD   #$7200                  ; 7360: CC 72 00      \n");
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7363; JUMP; // sstep
case 0x7363:
                                                     mon("         STD   $20,Y                   ; 7363: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7366; JUMP; // sstep
case 0x7366:
                                                     mon("         LDD   #$8040                  ; 7366: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7369; JUMP; // sstep
case 0x7369:
                                                     mon("         STD   $22,Y                   ; 7369: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x736C; JUMP; // sstep
case 0x736C:
                                                     mon("         LEAY  $24,Y                   ; 736C: 31 A8 24      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x24); 
/**/Z = Y; 
    PC = 0x736F; JUMP; // sstep
case 0x736F:
                                                     mon("         LDA   #$48                    ; 736F: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7371; JUMP; // sstep
case 0x7371:
                                                     mon("         TFR   A,DP                    ; 7371: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_72D5
    // ---------------------------------------------------------------------------
    PC = 0x7373; JUMP; // sstep
case 0x7373:
                                                     mon("         RTS                           ; 7373: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7375:
                                                     mon("L7375    LDA   #$5E                    ; 7375: 86 5E         \n"); // Tower top explode: Copy math points to vector RAM?
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7377; JUMP; // sstep
case 0x7377:
                                                     mon("         TFR   A,DP                    ; 7377: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x7379; JUMP; // sstep
case 0x7379:
                                                     mon("         LDD   <$1E                    ; 7379: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x737B; JUMP; // sstep
case 0x737B:
                                                     mon("         ADDD  #$FF98                  ; 737B: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x737E; JUMP; // sstep
case 0x737E:
                                                     mon("         ANDA  #$1F                    ; 737E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7380; JUMP; // sstep
case 0x7380:
                                                     mon("         STD   ,Y                      ; 7380: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7382; JUMP; // sstep
case 0x7382:
                                                     mon("         LDD   <$1C                    ; 7382: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7384; JUMP; // sstep
case 0x7384:
                                                     mon("         ANDA  #$1F                    ; 7384: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7386; JUMP; // sstep
case 0x7386:
                                                     mon("         STD   $02,Y                   ; 7386: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7388; JUMP; // sstep
case 0x7388:
                                                     mon("         LDD   #$A018                  ; 7388: CC A0 18      \n"); // Insert Vector JSRL 0018 instruction (STAT for colour fade?)
    clockticks = clockticks + 3; 
    A = 0xa0; 
    B = 0x18; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x738B; JUMP; // sstep
case 0x738B:
                                                     mon("         STD   $04,Y                   ; 738B: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x738D; JUMP; // sstep
case 0x738D:
                                                     mon("         LDD   <$0E                    ; 738D: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x738F; JUMP; // sstep
case 0x738F:
                                                     mon("         SUBD  <$1E                    ; 738F: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7391; JUMP; // sstep
case 0x7391:
                                                     mon("         ANDA  #$1F                    ; 7391: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7393; JUMP; // sstep
case 0x7393:
                                                     mon("         STD   $06,Y                   ; 7393: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7395; JUMP; // sstep
case 0x7395:
                                                     mon("         LDD   <$0C                    ; 7395: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7397; JUMP; // sstep
case 0x7397:
                                                     mon("         SUBD  <$1C                    ; 7397: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7399; JUMP; // sstep
case 0x7399:
                                                     mon("         ORA   #$E0                    ; 7399: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x739B; JUMP; // sstep
case 0x739B:
                                                     mon("         STD   $08,Y                   ; 739B: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x739D; JUMP; // sstep
case 0x739D:
                                                     mon("         LDD   <$2E                    ; 739D: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x739F; JUMP; // sstep
case 0x739F:
                                                     mon("         SUBD  <$0E                    ; 739F: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73A1; JUMP; // sstep
case 0x73A1:
                                                     mon("         ANDA  #$1F                    ; 73A1: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73A3; JUMP; // sstep
case 0x73A3:
                                                     mon("         STD   $0A,Y                   ; 73A3: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73A5; JUMP; // sstep
case 0x73A5:
                                                     mon("         LDD   <$2C                    ; 73A5: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73A7; JUMP; // sstep
case 0x73A7:
                                                     mon("         SUBD  <$0C                    ; 73A7: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73A9; JUMP; // sstep
case 0x73A9:
                                                     mon("         ORA   #$E0                    ; 73A9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73AB; JUMP; // sstep
case 0x73AB:
                                                     mon("         STD   $0C,Y                   ; 73AB: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73AD; JUMP; // sstep
case 0x73AD:
                                                     mon("         LDD   <$3E                    ; 73AD: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73AF; JUMP; // sstep
case 0x73AF:
                                                     mon("         SUBD  <$2E                    ; 73AF: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73B1; JUMP; // sstep
case 0x73B1:
                                                     mon("         ANDA  #$1F                    ; 73B1: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73B3; JUMP; // sstep
case 0x73B3:
                                                     mon("         STD   $0E,Y                   ; 73B3: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73B5; JUMP; // sstep
case 0x73B5:
                                                     mon("         LDD   <$3C                    ; 73B5: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73B7; JUMP; // sstep
case 0x73B7:
                                                     mon("         SUBD  <$2C                    ; 73B7: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73B9; JUMP; // sstep
case 0x73B9:
                                                     mon("         ORA   #$E0                    ; 73B9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73BB; JUMP; // sstep
case 0x73BB:
                                                     mon("         STD   $10,Y                   ; 73BB: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73BE; JUMP; // sstep
case 0x73BE:
                                                     mon("         LDD   <$1E                    ; 73BE: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73C0; JUMP; // sstep
case 0x73C0:
                                                     mon("         SUBD  <$3E                    ; 73C0: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73C2; JUMP; // sstep
case 0x73C2:
                                                     mon("         ANDA  #$1F                    ; 73C2: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73C4; JUMP; // sstep
case 0x73C4:
                                                     mon("         STD   $12,Y                   ; 73C4: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73C7; JUMP; // sstep
case 0x73C7:
                                                     mon("         LDD   <$1C                    ; 73C7: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73C9; JUMP; // sstep
case 0x73C9:
                                                     mon("         SUBD  <$3C                    ; 73C9: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73CB; JUMP; // sstep
case 0x73CB:
                                                     mon("         ORA   #$E0                    ; 73CB: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73CD; JUMP; // sstep
case 0x73CD:
                                                     mon("         STD   $14,Y                   ; 73CD: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73D0; JUMP; // sstep
case 0x73D0:
                                                     mon("         LDD   <$5E                    ; 73D0: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73D2; JUMP; // sstep
case 0x73D2:
                                                     mon("         SUBD  <$1E                    ; 73D2: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73D4; JUMP; // sstep
case 0x73D4:
                                                     mon("         ANDA  #$1F                    ; 73D4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73D6; JUMP; // sstep
case 0x73D6:
                                                     mon("         STD   $16,Y                   ; 73D6: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73D9; JUMP; // sstep
case 0x73D9:
                                                     mon("         LDD   <$5C                    ; 73D9: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73DB; JUMP; // sstep
case 0x73DB:
                                                     mon("         SUBD  <$1C                    ; 73DB: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73DD; JUMP; // sstep
case 0x73DD:
                                                     mon("         ORA   #$E0                    ; 73DD: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73DF; JUMP; // sstep
case 0x73DF:
                                                     mon("         STD   $18,Y                   ; 73DF: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73E2; JUMP; // sstep
case 0x73E2:
                                                     mon("         LDD   <$6E                    ; 73E2: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73E4; JUMP; // sstep
case 0x73E4:
                                                     mon("         SUBD  <$5E                    ; 73E4: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73E6; JUMP; // sstep
case 0x73E6:
                                                     mon("         ANDA  #$1F                    ; 73E6: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73E8; JUMP; // sstep
case 0x73E8:
                                                     mon("         STD   $1A,Y                   ; 73E8: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73EB; JUMP; // sstep
case 0x73EB:
                                                     mon("         LDD   <$6C                    ; 73EB: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73ED; JUMP; // sstep
case 0x73ED:
                                                     mon("         SUBD  <$5C                    ; 73ED: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73EF; JUMP; // sstep
case 0x73EF:
                                                     mon("         ORA   #$E0                    ; 73EF: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73F1; JUMP; // sstep
case 0x73F1:
                                                     mon("         STD   $1C,Y                   ; 73F1: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73F4; JUMP; // sstep
case 0x73F4:
                                                     mon("         LDD   <$3E                    ; 73F4: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73F6; JUMP; // sstep
case 0x73F6:
                                                     mon("         SUBD  <$6E                    ; 73F6: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x73F8; JUMP; // sstep
case 0x73F8:
                                                     mon("         ANDA  #$1F                    ; 73F8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x73FA; JUMP; // sstep
case 0x73FA:
                                                     mon("         STD   $1E,Y                   ; 73FA: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x73FD; JUMP; // sstep
case 0x73FD:
                                                     mon("         LDD   <$3C                    ; 73FD: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x73FF; JUMP; // sstep
case 0x73FF:
                                                     mon("         SUBD  <$6C                    ; 73FF: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7401; JUMP; // sstep
case 0x7401:
                                                     mon("         ORA   #$E0                    ; 7401: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7403; JUMP; // sstep
case 0x7403:
                                                     mon("         STD   $20,Y                   ; 7403: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7406; JUMP; // sstep
case 0x7406:
                                                     mon("         LDD   <$5E                    ; 7406: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7408; JUMP; // sstep
case 0x7408:
                                                     mon("         SUBD  <$3E                    ; 7408: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x740A; JUMP; // sstep
case 0x740A:
                                                     mon("         ANDA  #$1F                    ; 740A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x740C; JUMP; // sstep
case 0x740C:
                                                     mon("         STD   $22,Y                   ; 740C: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x740F; JUMP; // sstep
case 0x740F:
                                                     mon("         LDD   <$5C                    ; 740F: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7411; JUMP; // sstep
case 0x7411:
                                                     mon("         SUBD  <$3C                    ; 7411: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7413; JUMP; // sstep
case 0x7413:
                                                     mon("         ANDA  #$1F                    ; 7413: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7415; JUMP; // sstep
case 0x7415:
                                                     mon("         STD   $24,Y                   ; 7415: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7418; JUMP; // sstep
case 0x7418:
                                                     mon("         LDD   <$4E                    ; 7418: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x741A; JUMP; // sstep
case 0x741A:
                                                     mon("         SUBD  <$5E                    ; 741A: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x741C; JUMP; // sstep
case 0x741C:
                                                     mon("         ANDA  #$1F                    ; 741C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x741E; JUMP; // sstep
case 0x741E:
                                                     mon("         STD   $26,Y                   ; 741E: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7421; JUMP; // sstep
case 0x7421:
                                                     mon("         LDD   <$4C                    ; 7421: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7423; JUMP; // sstep
case 0x7423:
                                                     mon("         SUBD  <$5C                    ; 7423: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7425; JUMP; // sstep
case 0x7425:
                                                     mon("         ORA   #$E0                    ; 7425: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7427; JUMP; // sstep
case 0x7427:
                                                     mon("         STD   $28,Y                   ; 7427: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x742A; JUMP; // sstep
case 0x742A:
                                                     mon("         LDD   <$0E                    ; 742A: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x742C; JUMP; // sstep
case 0x742C:
                                                     mon("         SUBD  <$4E                    ; 742C: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x742E; JUMP; // sstep
case 0x742E:
                                                     mon("         ANDA  #$1F                    ; 742E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7430; JUMP; // sstep
case 0x7430:
                                                     mon("         STD   $2A,Y                   ; 7430: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7433; JUMP; // sstep
case 0x7433:
                                                     mon("         LDD   <$0C                    ; 7433: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7435; JUMP; // sstep
case 0x7435:
                                                     mon("         SUBD  <$4C                    ; 7435: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7437; JUMP; // sstep
case 0x7437:
                                                     mon("         ORA   #$E0                    ; 7437: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7439; JUMP; // sstep
case 0x7439:
                                                     mon("         STD   $2C,Y                   ; 7439: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x743C; JUMP; // sstep
case 0x743C:
                                                     mon("         LDD   #$7200                  ; 743C: CC 72 00      \n");
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x743F; JUMP; // sstep
case 0x743F:
                                                     mon("         STD   $2E,Y                   ; 743F: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7442; JUMP; // sstep
case 0x7442:
                                                     mon("         LDD   #$8040                  ; 7442: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7445; JUMP; // sstep
case 0x7445:
                                                     mon("         STD   $30,Y                   ; 7445: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7448; JUMP; // sstep
case 0x7448:
                                                     mon("         LEAY  $32,Y                   ; 7448: 31 A8 32      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x32); 
/**/Z = Y; 
    PC = 0x744B; JUMP; // sstep
case 0x744B:
                                                     mon("         LDA   #$48                    ; 744B: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x744D; JUMP; // sstep
case 0x744D:
                                                     mon("         TFR   A,DP                    ; 744D: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_7375
    // ---------------------------------------------------------------------------
    PC = 0x744F; JUMP; // sstep
case 0x744F:
                                                     mon("         RTS                           ; 744F: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7451:
                                                     mon("L7451    LDA   #$5E                    ; 7451: 86 5E         \n"); // Draws trench exhaust port
    clockticks = clockticks + 2; 
    val = (UINT8)0x5e; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7453; JUMP; // sstep
case 0x7453:
                                                     mon("         TFR   A,DP                    ; 7453: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    PC = 0x7455; JUMP; // sstep
case 0x7455:
                                                     mon("         LDD   <$5E                    ; 7455: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7457; JUMP; // sstep
case 0x7457:
                                                     mon("         ADDD  #$FF98                  ; 7457: C3 FF 98      \n");
    clockticks = clockticks + 4; 
    val = 0xff98; 
    arg = (A << 8) | B; 
    res = arg + val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x745A; JUMP; // sstep
case 0x745A:
                                                     mon("         ANDA  #$1F                    ; 745A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x745C; JUMP; // sstep
case 0x745C:
                                                     mon("         STD   ,Y                      ; 745C: ED A4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x745E; JUMP; // sstep
case 0x745E:
                                                     mon("         LDD   <$5C                    ; 745E: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7460; JUMP; // sstep
case 0x7460:
                                                     mon("         ANDA  #$1F                    ; 7460: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7462; JUMP; // sstep
case 0x7462:
                                                     mon("         STD   $02,Y                   ; 7462: ED 22         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7464; JUMP; // sstep
case 0x7464:
                                                     mon("         LDD   #$6280                  ; 7464: CC 62 80      \n"); // Insert Vector STAT 2,80 instruction (Green)
    clockticks = clockticks + 3; 
    A = 0x62; 
    B = 0x80; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7467; JUMP; // sstep
case 0x7467:
                                                     mon("         STD   $04,Y                   ; 7467: ED 24         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7469; JUMP; // sstep
case 0x7469:
                                                     mon("         LDD   <$9E                    ; 7469: DC 9E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x746B; JUMP; // sstep
case 0x746B:
                                                     mon("         SUBD  <$5E                    ; 746B: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x746D; JUMP; // sstep
case 0x746D:
                                                     mon("         ANDA  #$1F                    ; 746D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x746F; JUMP; // sstep
case 0x746F:
                                                     mon("         STD   $06,Y                   ; 746F: ED 26         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7471; JUMP; // sstep
case 0x7471:
                                                     mon("         LDD   <$9C                    ; 7471: DC 9C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x9c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x9d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7473; JUMP; // sstep
case 0x7473:
                                                     mon("         SUBD  <$5C                    ; 7473: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7475; JUMP; // sstep
case 0x7475:
                                                     mon("         ORA   #$E0                    ; 7475: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7477; JUMP; // sstep
case 0x7477:
                                                     mon("         STD   $08,Y                   ; 7477: ED 28         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x0008); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7479; JUMP; // sstep
case 0x7479:
                                                     mon("         LDD   <$8E                    ; 7479: DC 8E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x747B; JUMP; // sstep
case 0x747B:
                                                     mon("         SUBD  <$9E                    ; 747B: 93 9E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9e)<<8; 
    ea = ea | rd_mem(DP|0x9f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x747D; JUMP; // sstep
case 0x747D:
                                                     mon("         ANDA  #$1F                    ; 747D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x747F; JUMP; // sstep
case 0x747F:
                                                     mon("         STD   $0A,Y                   ; 747F: ED 2A         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7481; JUMP; // sstep
case 0x7481:
                                                     mon("         LDD   <$8C                    ; 7481: DC 8C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x8c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7483; JUMP; // sstep
case 0x7483:
                                                     mon("         SUBD  <$9C                    ; 7483: 93 9C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x9c)<<8; 
    ea = ea | rd_mem(DP|0x9d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7485; JUMP; // sstep
case 0x7485:
                                                     mon("         ORA   #$E0                    ; 7485: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7487; JUMP; // sstep
case 0x7487:
                                                     mon("         STD   $0C,Y                   ; 7487: ED 2C         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7489; JUMP; // sstep
case 0x7489:
                                                     mon("         LDD   <$4E                    ; 7489: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x748B; JUMP; // sstep
case 0x748B:
                                                     mon("         SUBD  <$8E                    ; 748B: 93 8E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8e)<<8; 
    ea = ea | rd_mem(DP|0x8f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x748D; JUMP; // sstep
case 0x748D:
                                                     mon("         ANDA  #$1F                    ; 748D: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x748F; JUMP; // sstep
case 0x748F:
                                                     mon("         STD   $0E,Y                   ; 748F: ED 2E         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + 0x000e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7491; JUMP; // sstep
case 0x7491:
                                                     mon("         LDD   <$4C                    ; 7491: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7493; JUMP; // sstep
case 0x7493:
                                                     mon("         SUBD  <$8C                    ; 7493: 93 8C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x8c)<<8; 
    ea = ea | rd_mem(DP|0x8d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7495; JUMP; // sstep
case 0x7495:
                                                     mon("         ORA   #$E0                    ; 7495: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7497; JUMP; // sstep
case 0x7497:
                                                     mon("         STD   $10,Y                   ; 7497: ED A8 10      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x10); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x749A; JUMP; // sstep
case 0x749A:
                                                     mon("         LDD   <$6E                    ; 749A: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x749C; JUMP; // sstep
case 0x749C:
                                                     mon("         SUBD  <$4E                    ; 749C: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x749E; JUMP; // sstep
case 0x749E:
                                                     mon("         ANDA  #$1F                    ; 749E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74A0; JUMP; // sstep
case 0x74A0:
                                                     mon("         STD   $12,Y                   ; 74A0: ED A8 12      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x12); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74A3; JUMP; // sstep
case 0x74A3:
                                                     mon("         LDD   <$6C                    ; 74A3: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74A5; JUMP; // sstep
case 0x74A5:
                                                     mon("         SUBD  <$4C                    ; 74A5: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74A7; JUMP; // sstep
case 0x74A7:
                                                     mon("         ANDA  #$1F                    ; 74A7: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74A9; JUMP; // sstep
case 0x74A9:
                                                     mon("         STD   $14,Y                   ; 74A9: ED A8 14      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x14); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74AC; JUMP; // sstep
case 0x74AC:
                                                     mon("         LDD   <$AE                    ; 74AC: DC AE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xae); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xaf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74AE; JUMP; // sstep
case 0x74AE:
                                                     mon("         SUBD  <$6E                    ; 74AE: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74B0; JUMP; // sstep
case 0x74B0:
                                                     mon("         ANDA  #$1F                    ; 74B0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74B2; JUMP; // sstep
case 0x74B2:
                                                     mon("         STD   $16,Y                   ; 74B2: ED A8 16      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x16); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74B5; JUMP; // sstep
case 0x74B5:
                                                     mon("         LDD   <$AC                    ; 74B5: DC AC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xac); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xad); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74B7; JUMP; // sstep
case 0x74B7:
                                                     mon("         SUBD  <$6C                    ; 74B7: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74B9; JUMP; // sstep
case 0x74B9:
                                                     mon("         ORA   #$E0                    ; 74B9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74BB; JUMP; // sstep
case 0x74BB:
                                                     mon("         STD   $18,Y                   ; 74BB: ED A8 18      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x18); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74BE; JUMP; // sstep
case 0x74BE:
                                                     mon("         LDD   <$BE                    ; 74BE: DC BE         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbe); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbf); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74C0; JUMP; // sstep
case 0x74C0:
                                                     mon("         SUBD  <$AE                    ; 74C0: 93 AE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xae)<<8; 
    ea = ea | rd_mem(DP|0xaf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74C2; JUMP; // sstep
case 0x74C2:
                                                     mon("         ANDA  #$1F                    ; 74C2: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74C4; JUMP; // sstep
case 0x74C4:
                                                     mon("         STD   $1A,Y                   ; 74C4: ED A8 1A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74C7; JUMP; // sstep
case 0x74C7:
                                                     mon("         LDD   <$BC                    ; 74C7: DC BC         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0xbc); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0xbd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74C9; JUMP; // sstep
case 0x74C9:
                                                     mon("         SUBD  <$AC                    ; 74C9: 93 AC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xac)<<8; 
    ea = ea | rd_mem(DP|0xad); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74CB; JUMP; // sstep
case 0x74CB:
                                                     mon("         ORA   #$E0                    ; 74CB: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74CD; JUMP; // sstep
case 0x74CD:
                                                     mon("         STD   $1C,Y                   ; 74CD: ED A8 1C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74D0; JUMP; // sstep
case 0x74D0:
                                                     mon("         LDD   <$7E                    ; 74D0: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74D2; JUMP; // sstep
case 0x74D2:
                                                     mon("         SUBD  <$BE                    ; 74D2: 93 BE         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbe)<<8; 
    ea = ea | rd_mem(DP|0xbf); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74D4; JUMP; // sstep
case 0x74D4:
                                                     mon("         ANDA  #$1F                    ; 74D4: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74D6; JUMP; // sstep
case 0x74D6:
                                                     mon("         STD   $1E,Y                   ; 74D6: ED A8 1E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x1e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74D9; JUMP; // sstep
case 0x74D9:
                                                     mon("         LDD   <$7C                    ; 74D9: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74DB; JUMP; // sstep
case 0x74DB:
                                                     mon("         SUBD  <$BC                    ; 74DB: 93 BC         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0xbc)<<8; 
    ea = ea | rd_mem(DP|0xbd); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74DD; JUMP; // sstep
case 0x74DD:
                                                     mon("         ORA   #$E0                    ; 74DD: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74DF; JUMP; // sstep
case 0x74DF:
                                                     mon("         STD   $20,Y                   ; 74DF: ED A8 20      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x20); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74E2; JUMP; // sstep
case 0x74E2:
                                                     mon("         LDD   #$6380                  ; 74E2: CC 63 80      \n"); // Insert Vector STAT 3,80 instruction (Red)
    clockticks = clockticks + 3; 
    A = 0x63; 
    B = 0x80; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74E5; JUMP; // sstep
case 0x74E5:
                                                     mon("         STD   $22,Y                   ; 74E5: ED A8 22      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x22); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74E8; JUMP; // sstep
case 0x74E8:
                                                     mon("         LDD   <$6E                    ; 74E8: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74EA; JUMP; // sstep
case 0x74EA:
                                                     mon("         SUBD  <$7E                    ; 74EA: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74EC; JUMP; // sstep
case 0x74EC:
                                                     mon("         ANDA  #$1F                    ; 74EC: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74EE; JUMP; // sstep
case 0x74EE:
                                                     mon("         STD   $24,Y                   ; 74EE: ED A8 24      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x24); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74F1; JUMP; // sstep
case 0x74F1:
                                                     mon("         LDD   <$6C                    ; 74F1: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74F3; JUMP; // sstep
case 0x74F3:
                                                     mon("         SUBD  <$7C                    ; 74F3: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74F5; JUMP; // sstep
case 0x74F5:
                                                     mon("         ORA   #$E0                    ; 74F5: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x74F7; JUMP; // sstep
case 0x74F7:
                                                     mon("         STD   $26,Y                   ; 74F7: ED A8 26      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x26); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x74FA; JUMP; // sstep
case 0x74FA:
                                                     mon("         LDD   <$2E                    ; 74FA: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x74FC; JUMP; // sstep
case 0x74FC:
                                                     mon("         SUBD  <$6E                    ; 74FC: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x74FE; JUMP; // sstep
case 0x74FE:
                                                     mon("         ANDA  #$1F                    ; 74FE: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7500; JUMP; // sstep
case 0x7500:
                                                     mon("         STD   $28,Y                   ; 7500: ED A8 28      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x28); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7503; JUMP; // sstep
case 0x7503:
                                                     mon("         LDD   <$2C                    ; 7503: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7505; JUMP; // sstep
case 0x7505:
                                                     mon("         SUBD  <$6C                    ; 7505: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7507; JUMP; // sstep
case 0x7507:
                                                     mon("         ORA   #$E0                    ; 7507: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7509; JUMP; // sstep
case 0x7509:
                                                     mon("         STD   $2A,Y                   ; 7509: ED A8 2A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x750C; JUMP; // sstep
case 0x750C:
                                                     mon("         LDD   <$6E                    ; 750C: DC 6E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x750E; JUMP; // sstep
case 0x750E:
                                                     mon("         SUBD  <$2E                    ; 750E: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7510; JUMP; // sstep
case 0x7510:
                                                     mon("         ANDA  #$1F                    ; 7510: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7512; JUMP; // sstep
case 0x7512:
                                                     mon("         STD   $2C,Y                   ; 7512: ED A8 2C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7515; JUMP; // sstep
case 0x7515:
                                                     mon("         LDD   <$6C                    ; 7515: DC 6C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x6c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x6d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7517; JUMP; // sstep
case 0x7517:
                                                     mon("         SUBD  <$2C                    ; 7517: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7519; JUMP; // sstep
case 0x7519:
                                                     mon("         ANDA  #$1F                    ; 7519: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x751B; JUMP; // sstep
case 0x751B:
                                                     mon("         STD   $2E,Y                   ; 751B: ED A8 2E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x2e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x751E; JUMP; // sstep
case 0x751E:
                                                     mon("         LDD   <$4E                    ; 751E: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7520; JUMP; // sstep
case 0x7520:
                                                     mon("         SUBD  <$6E                    ; 7520: 93 6E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6e)<<8; 
    ea = ea | rd_mem(DP|0x6f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7522; JUMP; // sstep
case 0x7522:
                                                     mon("         ANDA  #$1F                    ; 7522: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7524; JUMP; // sstep
case 0x7524:
                                                     mon("         STD   $30,Y                   ; 7524: ED A8 30      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x30); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7527; JUMP; // sstep
case 0x7527:
                                                     mon("         LDD   <$4C                    ; 7527: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7529; JUMP; // sstep
case 0x7529:
                                                     mon("         SUBD  <$6C                    ; 7529: 93 6C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x6c)<<8; 
    ea = ea | rd_mem(DP|0x6d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x752B; JUMP; // sstep
case 0x752B:
                                                     mon("         ORA   #$E0                    ; 752B: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x752D; JUMP; // sstep
case 0x752D:
                                                     mon("         STD   $32,Y                   ; 752D: ED A8 32      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x32); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7530; JUMP; // sstep
case 0x7530:
                                                     mon("         LDD   <$0E                    ; 7530: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7532; JUMP; // sstep
case 0x7532:
                                                     mon("         SUBD  <$4E                    ; 7532: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7534; JUMP; // sstep
case 0x7534:
                                                     mon("         ANDA  #$1F                    ; 7534: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7536; JUMP; // sstep
case 0x7536:
                                                     mon("         STD   $34,Y                   ; 7536: ED A8 34      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x34); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7539; JUMP; // sstep
case 0x7539:
                                                     mon("         LDD   <$0C                    ; 7539: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x753B; JUMP; // sstep
case 0x753B:
                                                     mon("         SUBD  <$4C                    ; 753B: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x753D; JUMP; // sstep
case 0x753D:
                                                     mon("         ORA   #$E0                    ; 753D: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x753F; JUMP; // sstep
case 0x753F:
                                                     mon("         STD   $36,Y                   ; 753F: ED A8 36      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x36); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7542; JUMP; // sstep
case 0x7542:
                                                     mon("         LDD   <$4E                    ; 7542: DC 4E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7544; JUMP; // sstep
case 0x7544:
                                                     mon("         SUBD  <$0E                    ; 7544: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7546; JUMP; // sstep
case 0x7546:
                                                     mon("         ANDA  #$1F                    ; 7546: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7548; JUMP; // sstep
case 0x7548:
                                                     mon("         STD   $38,Y                   ; 7548: ED A8 38      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x38); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x754B; JUMP; // sstep
case 0x754B:
                                                     mon("         LDD   <$4C                    ; 754B: DC 4C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x4c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x4d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x754D; JUMP; // sstep
case 0x754D:
                                                     mon("         SUBD  <$0C                    ; 754D: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x754F; JUMP; // sstep
case 0x754F:
                                                     mon("         ANDA  #$1F                    ; 754F: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7551; JUMP; // sstep
case 0x7551:
                                                     mon("         STD   $3A,Y                   ; 7551: ED A8 3A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7554; JUMP; // sstep
case 0x7554:
                                                     mon("         LDD   <$5E                    ; 7554: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7556; JUMP; // sstep
case 0x7556:
                                                     mon("         SUBD  <$4E                    ; 7556: 93 4E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4e)<<8; 
    ea = ea | rd_mem(DP|0x4f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7558; JUMP; // sstep
case 0x7558:
                                                     mon("         ANDA  #$1F                    ; 7558: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x755A; JUMP; // sstep
case 0x755A:
                                                     mon("         STD   $3C,Y                   ; 755A: ED A8 3C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x755D; JUMP; // sstep
case 0x755D:
                                                     mon("         LDD   <$5C                    ; 755D: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x755F; JUMP; // sstep
case 0x755F:
                                                     mon("         SUBD  <$4C                    ; 755F: 93 4C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x4c)<<8; 
    ea = ea | rd_mem(DP|0x4d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7561; JUMP; // sstep
case 0x7561:
                                                     mon("         ORA   #$E0                    ; 7561: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7563; JUMP; // sstep
case 0x7563:
                                                     mon("         STD   $3E,Y                   ; 7563: ED A8 3E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x3e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7566; JUMP; // sstep
case 0x7566:
                                                     mon("         LDD   <$1E                    ; 7566: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7568; JUMP; // sstep
case 0x7568:
                                                     mon("         SUBD  <$5E                    ; 7568: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x756A; JUMP; // sstep
case 0x756A:
                                                     mon("         ANDA  #$1F                    ; 756A: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x756C; JUMP; // sstep
case 0x756C:
                                                     mon("         STD   $40,Y                   ; 756C: ED A8 40      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x40); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x756F; JUMP; // sstep
case 0x756F:
                                                     mon("         LDD   <$1C                    ; 756F: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7571; JUMP; // sstep
case 0x7571:
                                                     mon("         SUBD  <$5C                    ; 7571: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7573; JUMP; // sstep
case 0x7573:
                                                     mon("         ORA   #$E0                    ; 7573: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7575; JUMP; // sstep
case 0x7575:
                                                     mon("         STD   $42,Y                   ; 7575: ED A8 42      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x42); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7578; JUMP; // sstep
case 0x7578:
                                                     mon("         LDD   <$5E                    ; 7578: DC 5E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x757A; JUMP; // sstep
case 0x757A:
                                                     mon("         SUBD  <$1E                    ; 757A: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x757C; JUMP; // sstep
case 0x757C:
                                                     mon("         ANDA  #$1F                    ; 757C: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x757E; JUMP; // sstep
case 0x757E:
                                                     mon("         STD   $44,Y                   ; 757E: ED A8 44      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x44); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7581; JUMP; // sstep
case 0x7581:
                                                     mon("         LDD   <$5C                    ; 7581: DC 5C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x5c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x5d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7583; JUMP; // sstep
case 0x7583:
                                                     mon("         SUBD  <$1C                    ; 7583: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7585; JUMP; // sstep
case 0x7585:
                                                     mon("         ANDA  #$1F                    ; 7585: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7587; JUMP; // sstep
case 0x7587:
                                                     mon("         STD   $46,Y                   ; 7587: ED A8 46      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x46); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x758A; JUMP; // sstep
case 0x758A:
                                                     mon("         LDD   <$7E                    ; 758A: DC 7E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x758C; JUMP; // sstep
case 0x758C:
                                                     mon("         SUBD  <$5E                    ; 758C: 93 5E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5e)<<8; 
    ea = ea | rd_mem(DP|0x5f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x758E; JUMP; // sstep
case 0x758E:
                                                     mon("         ANDA  #$1F                    ; 758E: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7590; JUMP; // sstep
case 0x7590:
                                                     mon("         STD   $48,Y                   ; 7590: ED A8 48      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x48); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7593; JUMP; // sstep
case 0x7593:
                                                     mon("         LDD   <$7C                    ; 7593: DC 7C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x7c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x7d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7595; JUMP; // sstep
case 0x7595:
                                                     mon("         SUBD  <$5C                    ; 7595: 93 5C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x5c)<<8; 
    ea = ea | rd_mem(DP|0x5d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7597; JUMP; // sstep
case 0x7597:
                                                     mon("         ORA   #$E0                    ; 7597: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7599; JUMP; // sstep
case 0x7599:
                                                     mon("         STD   $4A,Y                   ; 7599: ED A8 4A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x759C; JUMP; // sstep
case 0x759C:
                                                     mon("         LDD   <$3E                    ; 759C: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x759E; JUMP; // sstep
case 0x759E:
                                                     mon("         SUBD  <$7E                    ; 759E: 93 7E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7e)<<8; 
    ea = ea | rd_mem(DP|0x7f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75A0; JUMP; // sstep
case 0x75A0:
                                                     mon("         ANDA  #$1F                    ; 75A0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75A2; JUMP; // sstep
case 0x75A2:
                                                     mon("         STD   $4C,Y                   ; 75A2: ED A8 4C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75A5; JUMP; // sstep
case 0x75A5:
                                                     mon("         LDD   <$3C                    ; 75A5: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75A7; JUMP; // sstep
case 0x75A7:
                                                     mon("         SUBD  <$7C                    ; 75A7: 93 7C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x7c)<<8; 
    ea = ea | rd_mem(DP|0x7d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75A9; JUMP; // sstep
case 0x75A9:
                                                     mon("         ORA   #$E0                    ; 75A9: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75AB; JUMP; // sstep
case 0x75AB:
                                                     mon("         STD   $4E,Y                   ; 75AB: ED A8 4E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x4e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75AE; JUMP; // sstep
case 0x75AE:
                                                     mon("         LDD   #$64FF                  ; 75AE: CC 64 FF      \n"); // Insert Vector STAT 4,FF instruction ()
    clockticks = clockticks + 3; 
    A = 0x64; 
    B = 0xff; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75B1; JUMP; // sstep
case 0x75B1:
                                                     mon("         STD   $50,Y                   ; 75B1: ED A8 50      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x50); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75B4; JUMP; // sstep
case 0x75B4:
                                                     mon("         LDD   <$2E                    ; 75B4: DC 2E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75B6; JUMP; // sstep
case 0x75B6:
                                                     mon("         SUBD  <$3E                    ; 75B6: 93 3E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3e)<<8; 
    ea = ea | rd_mem(DP|0x3f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75B8; JUMP; // sstep
case 0x75B8:
                                                     mon("         ANDA  #$1F                    ; 75B8: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75BA; JUMP; // sstep
case 0x75BA:
                                                     mon("         STD   $52,Y                   ; 75BA: ED A8 52      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x52); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75BD; JUMP; // sstep
case 0x75BD:
                                                     mon("         LDD   <$2C                    ; 75BD: DC 2C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x2c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x2d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75BF; JUMP; // sstep
case 0x75BF:
                                                     mon("         SUBD  <$3C                    ; 75BF: 93 3C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x3c)<<8; 
    ea = ea | rd_mem(DP|0x3d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75C1; JUMP; // sstep
case 0x75C1:
                                                     mon("         ORA   #$E0                    ; 75C1: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75C3; JUMP; // sstep
case 0x75C3:
                                                     mon("         STD   $54,Y                   ; 75C3: ED A8 54      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x54); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75C6; JUMP; // sstep
case 0x75C6:
                                                     mon("         LDD   <$0E                    ; 75C6: DC 0E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75C8; JUMP; // sstep
case 0x75C8:
                                                     mon("         SUBD  <$2E                    ; 75C8: 93 2E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2e)<<8; 
    ea = ea | rd_mem(DP|0x2f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75CA; JUMP; // sstep
case 0x75CA:
                                                     mon("         ANDA  #$1F                    ; 75CA: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75CC; JUMP; // sstep
case 0x75CC:
                                                     mon("         STD   $56,Y                   ; 75CC: ED A8 56      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x56); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75CF; JUMP; // sstep
case 0x75CF:
                                                     mon("         LDD   <$0C                    ; 75CF: DC 0C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x0c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x0d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75D1; JUMP; // sstep
case 0x75D1:
                                                     mon("         SUBD  <$2C                    ; 75D1: 93 2C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x2c)<<8; 
    ea = ea | rd_mem(DP|0x2d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75D3; JUMP; // sstep
case 0x75D3:
                                                     mon("         ORA   #$E0                    ; 75D3: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75D5; JUMP; // sstep
case 0x75D5:
                                                     mon("         STD   $58,Y                   ; 75D5: ED A8 58      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x58); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75D8; JUMP; // sstep
case 0x75D8:
                                                     mon("         LDD   <$1E                    ; 75D8: DC 1E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75DA; JUMP; // sstep
case 0x75DA:
                                                     mon("         SUBD  <$0E                    ; 75DA: 93 0E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0e)<<8; 
    ea = ea | rd_mem(DP|0x0f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75DC; JUMP; // sstep
case 0x75DC:
                                                     mon("         ANDA  #$1F                    ; 75DC: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75DE; JUMP; // sstep
case 0x75DE:
                                                     mon("         STD   $5A,Y                   ; 75DE: ED A8 5A      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5a); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75E1; JUMP; // sstep
case 0x75E1:
                                                     mon("         LDD   <$1C                    ; 75E1: DC 1C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x1c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x1d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75E3; JUMP; // sstep
case 0x75E3:
                                                     mon("         SUBD  <$0C                    ; 75E3: 93 0C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x0c)<<8; 
    ea = ea | rd_mem(DP|0x0d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75E5; JUMP; // sstep
case 0x75E5:
                                                     mon("         ORA   #$E0                    ; 75E5: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75E7; JUMP; // sstep
case 0x75E7:
                                                     mon("         STD   $5C,Y                   ; 75E7: ED A8 5C      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5c); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75EA; JUMP; // sstep
case 0x75EA:
                                                     mon("         LDD   <$3E                    ; 75EA: DC 3E         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3e); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3f); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75EC; JUMP; // sstep
case 0x75EC:
                                                     mon("         SUBD  <$1E                    ; 75EC: 93 1E         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1e)<<8; 
    ea = ea | rd_mem(DP|0x1f); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75EE; JUMP; // sstep
case 0x75EE:
                                                     mon("         ANDA  #$1F                    ; 75EE: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75F0; JUMP; // sstep
case 0x75F0:
                                                     mon("         STD   $5E,Y                   ; 75F0: ED A8 5E      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x5e); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75F3; JUMP; // sstep
case 0x75F3:
                                                     mon("         LDD   <$3C                    ; 75F3: DC 3C         \n");
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x3c); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x3d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75F5; JUMP; // sstep
case 0x75F5:
                                                     mon("         SUBD  <$1C                    ; 75F5: 93 1C         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x1c)<<8; 
    ea = ea | rd_mem(DP|0x1d); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x75F7; JUMP; // sstep
case 0x75F7:
                                                     mon("         ORA   #$E0                    ; 75F7: 8A E0         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0xe0; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x75F9; JUMP; // sstep
case 0x75F9:
                                                     mon("         STD   $60,Y                   ; 75F9: ED A8 60      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x60); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x75FC; JUMP; // sstep
case 0x75FC:
                                                     mon("         LDD   #$7200                  ; 75FC: CC 72 00      \n"); // Insert Vector SCAL 2,00 instruction
    clockticks = clockticks + 3; 
    A = 0x72; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x75FF; JUMP; // sstep
case 0x75FF:
                                                     mon("         STD   $62,Y                   ; 75FF: ED A8 62      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x62); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7602; JUMP; // sstep
case 0x7602:
                                                     mon("         LDD   #$8040                  ; 7602: CC 80 40      \n"); // Insert Vector CNTR instruction
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7605; JUMP; // sstep
case 0x7605:
                                                     mon("         STD   $64,Y                   ; 7605: ED A8 64      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(Y + (SINT8)0x64); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7608; JUMP; // sstep
case 0x7608:
                                                     mon("         LEAY  $66,Y                   ; 7608: 31 A8 66      \n");
    clockticks = clockticks + 5; 
    Y = (Y + (SINT8)0x66); 
/**/Z = Y; 
    PC = 0x760B; JUMP; // sstep
case 0x760B:
                                                     mon("         LDA   #$48                    ; 760B: 86 48         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x48; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x760D; JUMP; // sstep
case 0x760D:
                                                     mon("         TFR   A,DP                    ; 760D: 1F 8B         \n");
    DP = (A) << 8; checkDP(); 
    // memory_DP = &memory[DP];
    clockticks = clockticks + 6; 
    // End of function sub_7451
    // ---------------------------------------------------------------------------
    PC = 0x760F; JUMP; // sstep
case 0x760F:
                                                     mon("         RTS                           ; 760F: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7D9A:
                                                     mon("L7D9A    LDD   <$89                    ; 7D9A: DC 89         \n"); // Get X 'forward' transform position
    clockticks = clockticks + 4; 
    A = rd_mem(DP|0x89); // Care needed with I/O space and word fetches
    B = rd_mem(DP|0x8a); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7D9C; JUMP; // sstep
case 0x7D9C:
                                                     mon("         STD   $5040                   ; 7D9C: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x7D9F; JUMP; // sstep
case 0x7D9F:
                                                     mon("         LDD   $4B24                   ; 7D9F: FC 4B 24      \n"); // Get Y 'horizontal' transform
    clockticks = clockticks + 5; 
    A = rd_mem(0x4b24); // Care needed with I/O space and word fetches
    B = rd_mem(0x4b25); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DA2; JUMP; // sstep
case 0x7DA2:
                                                     mon("         STD   $5042                   ; 7DA2: FD 50 42      \n"); // YT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x7DA5; JUMP; // sstep
case 0x7DA5:
                                                     mon("         LDD   $4B26                   ; 7DA5: FC 4B 26      \n"); // Get Z 'vertical' transform
    clockticks = clockticks + 5; 
    A = rd_mem(0x4b26); // Care needed with I/O space and word fetches
    B = rd_mem(0x4b27); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DA8; JUMP; // sstep
case 0x7DA8:
                                                     mon("         STD   $5044                   ; 7DA8: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    PC = 0x7DAB; JUMP; // sstep
case 0x7DAB:
                                                     mon("         LDX   #$4C00                  ; 7DAB: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7DAE; JUMP; // sstep
case 0x7DAE:
                                                     mon("         LDD   #$00                    ; 7DAE: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DB1; JUMP; // sstep
case 0x7DB1:
                                                     mon("L7DB1    STD   ,X++                    ; 7DB1: ED 81         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    X = X + 2; 
    PC = 0x7DB3; JUMP; // sstep
case 0x7DB3:
                                                     mon("         CMPX  #$4C80                  ; 7DB3: 8C 4C 80      \n"); // Clear star dots RAM
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x4c80; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7DB6; JUMP; // sstep
case 0x7DB6:
                                                     mon("         BCS   $7DB1                   ; 7DB6: 25 F9         \n");
    // temp fix to ensure flags synched
    if (C) {
    PC = 0x7db1; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7DB8; JUMP; // sstep
case 0x7DB8:
                                                     mon("         STA   <$88                    ; 7DB8: 97 88         \n"); // Clear DPbyte_88
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x88; 
    wr_mem(ea, val); 
    PC = 0x7DBA; JUMP; // sstep
case 0x7DBA:
                                                     mon("         LDA   #$67                    ; 7DBA: 86 67         \n"); // Insert Vector STAT 7 for white stars
    clockticks = clockticks + 2; 
    val = (UINT8)0x67; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7DBC; JUMP; // sstep
case 0x7DBC:
                                                     mon("         LDB   <$83                    ; 7DBC: D6 83         \n"); // Star intensity
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x83); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7DBE; JUMP; // sstep
case 0x7DBE:
                                                     mon("         STD   ,Y++                    ; 7DBE: ED A1         \n"); // Y points to vector RAM
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7DC0; JUMP; // sstep
case 0x7DC0:
                                                     mon("         LDD   #$018C                  ; 7DC0: CC 01 8C      \n"); // Point BIC to Math RAM $5C60
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0x8c; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DC3; JUMP; // sstep
case 0x7DC3:
                                                     mon("         STD   $4701                   ; 7DC3: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x7DC6; JUMP; // sstep
case 0x7DC6:
                                                     mon("         STB   <$82                    ; 7DC6: D7 82         \n"); // Store $8C to DPbyte_82
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x82; 
    wr_mem(ea, val); 
    PC = 0x7DC8; JUMP; // sstep
case 0x7DC8:
                                                     mon("         NEGB                          ; 7DC8: 50            \n"); // Negate to $74
    val = (UINT8)B; 
    res = -val; 
/**/V = val & (UINT8)res; 
/**/C = res & 0x100; 
    val = (UINT8)res; 
    B = val; 
/**/Z = val; 
/**/N = val; 
    clockticks = clockticks + 2; 
    PC = 0x7DC9; JUMP; // sstep
case 0x7DC9:
                                                     mon("         ADDB  #$BE                    ; 7DC9: CB BE         \n"); // Add $BE to get $32
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    arg = 0xbe; 
    res = val + (UINT8)arg; 
    C = (res >> 1) & 0x80; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
    H = (UINT8)((val ^ arg) ^ (res ^ C)); 
/**/V = (UINT8)((val ^ arg) ^ (res ^ C)); 
    B = (UINT8)res; 
    PC = 0x7DCB; JUMP; // sstep
case 0x7DCB:
                                                     mon("         STB   <$81                    ; 7DCB: D7 81         \n"); // Store $32 in DPbyte_81 (why not just load B with $32 ?)
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x81; 
    wr_mem(ea, val); 
    PC = 0x7DCD; JUMP; // sstep
case 0x7DCD:
                                                     mon("         LDU   #$4C80                  ; 7DCD: CE 4C 80      \n");
    clockticks = clockticks + 3; 
    U = 0x4c80; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x7DD0; JUMP; // sstep
case 0x7DD0:
                                                     mon("         LDX   #$5C60                  ; 7DD0: 8E 5C 60      \n");
    clockticks = clockticks + 3; 
    X = 0x5c60; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7DD3; JUMP; // sstep
case 0x7DD3:
                                                     mon("L7DD3    STX   <$84                    ; 7DD3: 9F 84         \n"); // DPbyte_84 holds running star MRAM pointer
    clockticks = clockticks + 4; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = DP|0x84; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7DD5; JUMP; // sstep
case 0x7DD5:
                                                     mon("         LDA   #$67                    ; 7DD5: 86 67         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x67; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7DD7; JUMP; // sstep
case 0x7DD7:
                                                     mon("         JSR   $CDBA                   ; 7DD7: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xda); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7d); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x7DDA:
                                                     mon("L7DDA    LDD   $5000                   ; 7DDA: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DDD; JUMP; // sstep
case 0x7DDD:
                                                     mon("         CMPD  #$0100                  ; 7DDD: 10 83 01 00   \n");
    clockticks = clockticks + 5; 
    val = (((UINT8)A<<8)|(UINT8)B); 
    arg = 0x0100; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7DE1; JUMP; // sstep
case 0x7DE1:
                                                     mon("         LBLE  $7E5D                   ; 7DE1: 10 2F 00 78   \n");
    clockticks = clockticks + 5; 
    if (((SINT8)(N^V) <  0) || (!Z)) {
    clockticks = clockticks + 1; 
    PC = 0x7e5d; 
    JUMP;
    }
    PC = 0x7DE5; JUMP; // sstep
case 0x7DE5:
                                                     mon("         CMPD  #$0FFF                  ; 7DE5: 10 83 0F FF   \n");
    clockticks = clockticks + 5; 
    val = (((UINT8)A<<8)|(UINT8)B); 
    arg = 0x0fff; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7DE9; JUMP; // sstep
case 0x7DE9:
                                                     mon("         LBHI  $7E5D                   ; 7DE9: 10 22 00 70   \n"); // Check perspective division value?
    clockticks = clockticks + 5; 
    if (Z && (!C)) {
    clockticks = clockticks + 1; 
    PC = 0x7e5d; 
    JUMP;
    }
    PC = 0x7DED; JUMP; // sstep
case 0x7DED:
                                                     mon("         STD   $4704                   ; 7DED: FD 47 04      \n"); // Start division
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x7DF0; JUMP; // sstep
case 0x7DF0:
                                                     mon("         LDD   $5072                   ; 7DF0: FC 50 72      \n"); // Reg39 = Reg01 x Reg01
    clockticks = clockticks + 5; 
    A = rd_mem(0x5072); // Care needed with I/O space and word fetches
    B = rd_mem(0x5073); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DF3; JUMP; // sstep
case 0x7DF3:
                                                     mon("         SUBD  $5070                   ; 7DF3: B3 50 70      \n"); // Reg38 = Reg00 x Reg00
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5070)<<8; 
    ea = ea | rd_mem(0x5071); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
    N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7DF6; JUMP; // sstep
case 0x7DF6:
                                                     mon("         LBCC  $7E5D                   ; 7DF6: 10 24 00 63   \n");
    clockticks = clockticks + 5; 
    if (!C) {
    clockticks = clockticks + 1; 
    PC = 0x7e5d; 
    JUMP;
    }
    PC = 0x7DFA; JUMP; // sstep
case 0x7DFA:
                                                     mon("         LDD   $5074                   ; 7DFA: FC 50 74      \n"); // Reg3A = Reg02 x Reg02
    clockticks = clockticks + 5; 
    A = rd_mem(0x5074); // Care needed with I/O space and word fetches
    B = rd_mem(0x5075); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7DFD; JUMP; // sstep
case 0x7DFD:
                                                     mon("         SUBD  $5070                   ; 7DFD: B3 50 70      \n");
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5070)<<8; 
    ea = ea | rd_mem(0x5071); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
    N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7E00; JUMP; // sstep
case 0x7E00:
                                                     mon("         LBCC  $7E5D                   ; 7E00: 10 24 00 59   \n");
    clockticks = clockticks + 5; 
    if (!C) {
    clockticks = clockticks + 1; 
    PC = 0x7e5d; 
    JUMP;
    }
    PC = 0x7E04; JUMP; // sstep
case 0x7E04:
                                                     mon("         LDD   $4700                   ; 7E04: FC 47 00      \n"); // Get division result
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E07; JUMP; // sstep
case 0x7E07:
                                                     mon("         STD   $5000                   ; 7E07: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x7E0A; JUMP; // sstep
case 0x7E0A:
                                                     mon("         LDA   #$86                    ; 7E0A: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7E0C; JUMP; // sstep
case 0x7E0C:
                                                     mon("         JSR   $CDBA                   ; 7E0C: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x0f); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7e); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x7E0F:
                                                     mon("L7E0F    CLRB                          ; 7E0F: 5F            \n");
    B = 0; 
/**/V = 0; 
/**/Z = 0; 
/**/N = 0; 
/**/C = 0; 
    clockticks = clockticks + 2; 
    PC = 0x7E10; JUMP; // sstep
case 0x7E10:
                                                     mon("         LDA   $5004                   ; 7E10: B6 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5004); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7E13; JUMP; // sstep
case 0x7E13:
                                                     mon("         LSRA                          ; 7E13: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7E14; JUMP; // sstep
case 0x7E14:
                                                     mon("         ROLB                          ; 7E14: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7E15; JUMP; // sstep
case 0x7E15:
                                                     mon("         LSRA                          ; 7E15: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7E16; JUMP; // sstep
case 0x7E16:
                                                     mon("         ROLB                          ; 7E16: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7E17; JUMP; // sstep
case 0x7E17:
                                                     mon("         LDA   $5002                   ; 7E17: B6 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5002); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7E1A; JUMP; // sstep
case 0x7E1A:
                                                     mon("         LSRA                          ; 7E1A: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7E1B; JUMP; // sstep
case 0x7E1B:
                                                     mon("         ROLB                          ; 7E1B: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7E1C; JUMP; // sstep
case 0x7E1C:
                                                     mon("         LSRA                          ; 7E1C: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7E1D; JUMP; // sstep
case 0x7E1D:
                                                     mon("         ROLB                          ; 7E1D: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7E1E; JUMP; // sstep
case 0x7E1E:
                                                     mon("         LDA   #$08                    ; 7E1E: 86 08         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x08; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7E20; JUMP; // sstep
case 0x7E20:
                                                     mon("         MUL                           ; 7E20: 3D            \n");
    res = (UINT16)(A * B); 
/**/Z = res; 
    C = res & 0x80; 
    A = res >> 8; 
    B = (UINT8)res; 
    clockticks = clockticks + 11; 
    PC = 0x7E21; JUMP; // sstep
case 0x7E21:
                                                     mon("         LDX   #$4C00                  ; 7E21: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7E24; JUMP; // sstep
case 0x7E24:
                                                     mon("         ABX                           ; 7E24: 3A            \n");
    X = X + B; 
    clockticks = clockticks + 3; 
    PC = 0x7E25; JUMP; // sstep
case 0x7E25:
                                                     mon("         LDD   $02,X                   ; 7E25: EC 02         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
    Z = A|B; 
    N = A; 
    V = 0; 
    PC = 0x7E27; JUMP; // sstep
case 0x7E27:
                                                     mon("         BNE   L7E2D                   ; 7E27: 26 04         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x7e2d; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7E29; JUMP; // sstep
case 0x7E29:
                                                     mon("         STU   $02,X                   ; 7E29: EF 02         \n");
    clockticks = clockticks + 5; 
    val = U; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = (X + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7E2B; JUMP; // sstep
case 0x7E2B:
                                                     mon("         BRA   $7E2F                   ; 7E2B: 20 02         \n");
    PC = 0x7e2f; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x7E2D:
                                                     mon("L7E2D    STU   [,X]                    ; 7E2D: EF 94         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 2; 
    clockticks = clockticks + 1; 
    ea = rd_mem(X)<<8; 
    ea = ea | rd_mem((UINT16)((X)+1)); 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = ea; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7E2F; JUMP; // sstep
case 0x7E2F:
                                                     mon("L7E2F    STU   ,X                      ; 7E2F: EF 84         \n");
    clockticks = clockticks + 4; 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7E31; JUMP; // sstep
case 0x7E31:
                                                     mon("         LDD   #$00                    ; 7E31: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E34; JUMP; // sstep
case 0x7E34:
                                                     mon("         STD   ,U                      ; 7E34: ED C4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = U; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7E36; JUMP; // sstep
case 0x7E36:
                                                     mon("         LDD   $5004                   ; 7E36: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E39; JUMP; // sstep
case 0x7E39:
                                                     mon("         SUBD  $06,X                   ; 7E39: A3 06         \n");
    clockticks = clockticks + 1; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0006))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0006))+1)); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7E3B; JUMP; // sstep
case 0x7E3B:
                                                     mon("         ANDA  #$1F                    ; 7E3B: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7E3D; JUMP; // sstep
case 0x7E3D:
                                                     mon("         STD   $04,U                   ; 7E3D: ED 44         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7E3F; JUMP; // sstep
case 0x7E3F:
                                                     mon("         LDD   $5002                   ; 7E3F: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E42; JUMP; // sstep
case 0x7E42:
                                                     mon("         SUBD  $04,X                   ; 7E42: A3 04         \n");
    clockticks = clockticks + 1; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0004))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0004))+1)); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7E44; JUMP; // sstep
case 0x7E44:
                                                     mon("         ANDA  #$1F                    ; 7E44: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7E46; JUMP; // sstep
case 0x7E46:
                                                     mon("         CMPU  $02,X                   ; 7E46: 11 A3 02      \n");
    clockticks = clockticks + 2; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0002))+1)); 
    val = U; 
    arg = ea; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7E49; JUMP; // sstep
case 0x7E49:
                                                     mon("         BEQ   $7E4D                   ; 7E49: 27 02         \n"); // These 3 lines surely do nothing as ORA #0 does nothing ?
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x7e4d; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7E4B; JUMP; // sstep
case 0x7E4B:
                                                     mon("         ORA   #$00                    ; 7E4B: 8A 00         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0x00; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7E4D; JUMP; // sstep
case 0x7E4D:
                                                     mon("L7E4D    STD   $02,U                   ; 7E4D: ED 42         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7E4F; JUMP; // sstep
case 0x7E4F:
                                                     mon("         LDD   $5004                   ; 7E4F: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E52; JUMP; // sstep
case 0x7E52:
                                                     mon("         STD   $06,X                   ; 7E52: ED 06         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7E54; JUMP; // sstep
case 0x7E54:
                                                     mon("         LDD   $5002                   ; 7E54: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E57; JUMP; // sstep
case 0x7E57:
                                                     mon("         STD   $04,X                   ; 7E57: ED 04         \n");
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = (UINT16)(X + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7E59; JUMP; // sstep
case 0x7E59:
                                                     mon("         LEAU  $06,U                   ; 7E59: 33 46         \n");
    clockticks = clockticks + 5; 
    U = (U + 0x0006); 
    PC = 0x7E5B; JUMP; // sstep
case 0x7E5B:
                                                     mon("         BRA   $7E62                   ; 7E5B: 20 05         \n");
    PC = 0x7e62; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x7E5D:
                                                     mon("L7E5D    LDX   <$84                    ; 7E5D: 9E 84         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x84)<<8; 
    ea = ea | rd_mem(DP|0x85); 
    X = ea; 
    Z = X; 
    N = (X) >> 8; 
    V = 0; 
    PC = 0x7E5F; JUMP; // sstep
case 0x7E5F:
                                                     mon("         JSR   L7F9A                   ; 7E5F: BD 7F 9A      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x62); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7e); 
    clockticks = clockticks + 1; 
    PC = 0x7f9a; 
    JUMP;
  case 0x7E62:
                                                     mon("L7E62    INC   <$82                    ; 7E62: 0C 82         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x82); 
    res = (UINT8)(val + 1); 
/**/Z = res; 
/**/N = res; 
/**/V = res & ~val; 
    wr_mem(DP|0x82, res); 
    clockticks = clockticks + 2; 
    PC = 0x7E64; JUMP; // sstep
case 0x7E64:
                                                     mon("         LDX   <$84                    ; 7E64: 9E 84         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x84)<<8; 
    ea = ea | rd_mem(DP|0x85); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7E66; JUMP; // sstep
case 0x7E66:
                                                     mon("         LEAX  $08,X                   ; 7E66: 30 08         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0008); 
/**/Z = X; 
    PC = 0x7E68; JUMP; // sstep
case 0x7E68:
                                                     mon("         DEC   <$81                    ; 7E68: 0A 81         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x81); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x81, res); 
    clockticks = clockticks + 2; 
    PC = 0x7E6A; JUMP; // sstep
case 0x7E6A:
                                                     mon("         LBNE  $7DD3                   ; 7E6A: 10 26 FF 65   \n");
    clockticks = clockticks + 5; 
    if (Z) {
    clockticks = clockticks + 1; 
    PC = 0x7dd3; 
    JUMP;
    }
    PC = 0x7E6E; JUMP; // sstep
case 0x7E6E:
                                                     mon("         LDX   #$4C00                  ; 7E6E: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7E71; JUMP; // sstep
case 0x7E71:
                                                     mon("L7E71    LDU   $02,X                   ; 7E71: EE 02         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0002))+1)); 
    U = ea; 
    Z = U; 
    N = (U) >> 8; 
    V = 0; 
    PC = 0x7E73; JUMP; // sstep
case 0x7E73:
                                                     mon("         BEQ   $7E95                   ; 7E73: 27 20         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x7e95; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7E75; JUMP; // sstep
case 0x7E75:
                                                     mon("         LDD   #$1F98                  ; 7E75: CC 1F 98      \n"); // Starfield Y offset
    clockticks = clockticks + 3; 
    A = 0x1f; 
    B = 0x98; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E78; JUMP; // sstep
case 0x7E78:
                                                     mon("         STD   ,Y++                    ; 7E78: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E7A; JUMP; // sstep
case 0x7E7A:
                                                     mon("         LDD   #$00                    ; 7E7A: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E7D; JUMP; // sstep
case 0x7E7D:
                                                     mon("         STD   ,Y++                    ; 7E7D: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E7F; JUMP; // sstep
case 0x7E7F:
                                                     mon("L7E7F    LDD   $04,U                   ; 7E7F: EC 44         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(U + 0x0004); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E81; JUMP; // sstep
case 0x7E81:
                                                     mon("         STD   ,Y++                    ; 7E81: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E83; JUMP; // sstep
case 0x7E83:
                                                     mon("         LDD   $02,U                   ; 7E83: EC 42         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(U + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E85; JUMP; // sstep
case 0x7E85:
                                                     mon("         STD   ,Y++                    ; 7E85: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E87; JUMP; // sstep
case 0x7E87:
                                                     mon("         LDD   $33DC                   ; 7E87: FC 33 DC      \n"); // JSRL to Vector ROM subroutine to draw dot
    clockticks = clockticks + 5; 
    A = rd_mem(0x33dc); // Care needed with I/O space and word fetches
    B = rd_mem(0x33dd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E8A; JUMP; // sstep
case 0x7E8A:
                                                     mon("         STD   ,Y++                    ; 7E8A: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E8C; JUMP; // sstep
case 0x7E8C:
                                                     mon("         LDU   ,U                      ; 7E8C: EE C4         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(U)<<8; 
    ea = ea | rd_mem((UINT16)((U)+1)); 
    U = ea; 
    Z = U; 
    N = (U) >> 8; 
    V = 0; 
    PC = 0x7E8E; JUMP; // sstep
case 0x7E8E:
                                                     mon("         BNE   $7E7F                   ; 7E8E: 26 EF         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x7e7f; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7E90; JUMP; // sstep
case 0x7E90:
                                                     mon("         LDD   #$8040                  ; 7E90: CC 80 40      \n"); // Insert Vector CNTR
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E93; JUMP; // sstep
case 0x7E93:
                                                     mon("         STD   ,Y++                    ; 7E93: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7E95; JUMP; // sstep
case 0x7E95:
                                                     mon("L7E95    LEAX  $08,X                   ; 7E95: 30 08         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0008); 
/**/Z = X; 
    PC = 0x7E97; JUMP; // sstep
case 0x7E97:
                                                     mon("         CMPX  #$4C80                  ; 7E97: 8C 4C 80      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x4c80; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7E9A; JUMP; // sstep
case 0x7E9A:
                                                     mon("         BCS   $7E71                   ; 7E9A: 25 D5         \n");
    // temp fix to ensure flags synched
    if (C) {
    PC = 0x7e71; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7E9C; JUMP; // sstep
case 0x7E9C:
                                                     mon("         LDD   $5098                   ; 7E9C: FC 50 98      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5098); // Care needed with I/O space and word fetches
    B = rd_mem(0x5099); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7E9F; JUMP; // sstep
case 0x7E9F:
                                                     mon("         STD   $5040                   ; 7E9F: FD 50 40      \n"); // XT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5040, A); // Care needed with I/O space and word fetches
    wr_mem(0x5041, B); 
    PC = 0x7EA2; JUMP; // sstep
case 0x7EA2:
                                                     mon("         LDD   $509A                   ; 7EA2: FC 50 9A      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509a); // Care needed with I/O space and word fetches
    B = rd_mem(0x509b); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EA5; JUMP; // sstep
case 0x7EA5:
                                                     mon("         STD   $5042                   ; 7EA5: FD 50 42      \n"); // YT2
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5042, A); // Care needed with I/O space and word fetches
    wr_mem(0x5043, B); 
    PC = 0x7EA8; JUMP; // sstep
case 0x7EA8:
                                                     mon("         LDD   $509C                   ; 7EA8: FC 50 9C      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x509c); // Care needed with I/O space and word fetches
    B = rd_mem(0x509d); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EAB; JUMP; // sstep
case 0x7EAB:
                                                     mon("         STD   $5044                   ; 7EAB: FD 50 44      \n"); // ZT2
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    wr_mem(0x5044, A); // Care needed with I/O space and word fetches
    wr_mem(0x5045, B); 
    // End of function sub_7D9A
    PC = 0x7EAE; JUMP; // sstep
case 0x7EAE:
                                                     mon("         RTS                           ; 7EAE: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7EAF:
                                                     mon("L7EAF    LDX   #$4C00                  ; 7EAF: 8E 4C 00      \n"); // Towers surface dots
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7EB2; JUMP; // sstep
case 0x7EB2:
                                                     mon("         LDD   #$00                    ; 7EB2: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EB5; JUMP; // sstep
case 0x7EB5:
                                                     mon("L7EB5    STD   ,X++                    ; 7EB5: ED 81         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    X = X + 2; 
    PC = 0x7EB7; JUMP; // sstep
case 0x7EB7:
                                                     mon("         CMPX  #$4C80                  ; 7EB7: 8C 4C 80      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x4c80; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7EBA; JUMP; // sstep
case 0x7EBA:
                                                     mon("         BCS   $7EB5                   ; 7EBA: 25 F9         \n");
    // temp fix to ensure flags synched
    if (C) {
    PC = 0x7eb5; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7EBC; JUMP; // sstep
case 0x7EBC:
                                                     mon("         STA   <$88                    ; 7EBC: 97 88         \n");
    clockticks = clockticks + 4; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x88; 
    wr_mem(ea, val); 
    PC = 0x7EBE; JUMP; // sstep
case 0x7EBE:
                                                     mon("         LDD   #$6280                  ; 7EBE: CC 62 80      \n"); // Insert Vector STAT 2, 80 for green dots
    clockticks = clockticks + 3; 
    A = 0x62; 
    B = 0x80; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EC1; JUMP; // sstep
case 0x7EC1:
                                                     mon("         STD   ,Y++                    ; 7EC1: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7EC3; JUMP; // sstep
case 0x7EC3:
                                                     mon("         LDD   #$018C                  ; 7EC3: CC 01 8C      \n"); // Point BIC to Math RAM $5C60
    clockticks = clockticks + 3; 
    A = 0x01; 
    B = 0x8c; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EC6; JUMP; // sstep
case 0x7EC6:
                                                     mon("         STD   $4701                   ; 7EC6: FD 47 01      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4701, A); // Care needed with I/O space and word fetches
    wr_mem(0x4702, B); 
    PC = 0x7EC9; JUMP; // sstep
case 0x7EC9:
                                                     mon("         STB   <$82                    ; 7EC9: D7 82         \n");
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x82; 
    wr_mem(ea, val); 
    PC = 0x7ECB; JUMP; // sstep
case 0x7ECB:
                                                     mon("         NEGB                          ; 7ECB: 50            \n");
    val = (UINT8)B; 
    res = -val; 
/**/V = val & (UINT8)res; 
/**/C = res & 0x100; 
    val = (UINT8)res; 
    B = val; 
/**/Z = val; 
/**/N = val; 
    clockticks = clockticks + 2; 
    PC = 0x7ECC; JUMP; // sstep
case 0x7ECC:
                                                     mon("         ADDB  #$BE                    ; 7ECC: CB BE         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    arg = 0xbe; 
    res = val + (UINT8)arg; 
    C = (res >> 1) & 0x80; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
    H = (UINT8)((val ^ arg) ^ (res ^ C)); 
/**/V = (UINT8)((val ^ arg) ^ (res ^ C)); 
    B = (UINT8)res; 
    PC = 0x7ECE; JUMP; // sstep
case 0x7ECE:
                                                     mon("         STB   <$81                    ; 7ECE: D7 81         \n");
    clockticks = clockticks + 4; 
    val = B; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    ea = DP|0x81; 
    wr_mem(ea, val); 
    PC = 0x7ED0; JUMP; // sstep
case 0x7ED0:
                                                     mon("         LDU   #$4C80                  ; 7ED0: CE 4C 80      \n");
    clockticks = clockticks + 3; 
    U = 0x4c80; 
/**/Z = U; 
/**/N = (U) >> 8; 
/**/V = 0; 
    PC = 0x7ED3; JUMP; // sstep
case 0x7ED3:
                                                     mon("         LDX   #$5C60                  ; 7ED3: 8E 5C 60      \n");
    clockticks = clockticks + 3; 
    X = 0x5c60; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7ED6; JUMP; // sstep
case 0x7ED6:
                                                     mon("L7ED6    STX   <$84                    ; 7ED6: 9F 84         \n");
    clockticks = clockticks + 4; 
    val = X; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = DP|0x84; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7ED8; JUMP; // sstep
case 0x7ED8:
                                                     mon("         LDA   #$67                    ; 7ED8: 86 67         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x67; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7EDA; JUMP; // sstep
case 0x7EDA:
                                                     mon("         JSR   $CDBA                   ; 7EDA: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xdd); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7e); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x7EDD:
                                                     mon("L7EDD    LDD   $5000                   ; 7EDD: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EE0; JUMP; // sstep
case 0x7EE0:
                                                     mon("         CMPD  #$0100                  ; 7EE0: 10 83 01 00   \n");
    clockticks = clockticks + 5; 
    val = (((UINT8)A<<8)|(UINT8)B); 
    arg = 0x0100; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7EE4; JUMP; // sstep
case 0x7EE4:
                                                     mon("         LBLE  L7F58                   ; 7EE4: 10 2F 00 70   \n");
    clockticks = clockticks + 5; 
    if (((SINT8)(N^V) <  0) || (!Z)) {
    clockticks = clockticks + 1; 
    PC = 0x7f58; 
    JUMP;
    }
    PC = 0x7EE8; JUMP; // sstep
case 0x7EE8:
                                                     mon("         STD   $4704                   ; 7EE8: FD 47 04      \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x4704, A); // Care needed with I/O space and word fetches
    wr_mem(0x4705, B); 
    PC = 0x7EEB; JUMP; // sstep
case 0x7EEB:
                                                     mon("         LDD   $5072                   ; 7EEB: FC 50 72      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5072); // Care needed with I/O space and word fetches
    B = rd_mem(0x5073); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EEE; JUMP; // sstep
case 0x7EEE:
                                                     mon("         SUBD  $5070                   ; 7EEE: B3 50 70      \n");
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5070)<<8; 
    ea = ea | rd_mem(0x5071); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
    N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7EF1; JUMP; // sstep
case 0x7EF1:
                                                     mon("         LBCC  L7F58                   ; 7EF1: 10 24 00 63   \n");
    clockticks = clockticks + 5; 
    if (!C) {
    clockticks = clockticks + 1; 
    PC = 0x7f58; 
    JUMP;
    }
    PC = 0x7EF5; JUMP; // sstep
case 0x7EF5:
                                                     mon("         LDD   $5074                   ; 7EF5: FC 50 74      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x5074); // Care needed with I/O space and word fetches
    B = rd_mem(0x5075); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7EF8; JUMP; // sstep
case 0x7EF8:
                                                     mon("         SUBD  $5070                   ; 7EF8: B3 50 70      \n");
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5070)<<8; 
    ea = ea | rd_mem(0x5071); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
    N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7EFB; JUMP; // sstep
case 0x7EFB:
                                                     mon("         LBCC  L7F58                   ; 7EFB: 10 24 00 59   \n");
    clockticks = clockticks + 5; 
    if (!C) {
    clockticks = clockticks + 1; 
    PC = 0x7f58; 
    JUMP;
    }
    PC = 0x7EFF; JUMP; // sstep
case 0x7EFF:
                                                     mon("         LDD   $4700                   ; 7EFF: FC 47 00      \n");
    clockticks = clockticks + 5; 
    A = rd_mem(0x4700); // Care needed with I/O space and word fetches
    B = rd_mem(0x4701); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F02; JUMP; // sstep
case 0x7F02:
                                                     mon("         STD   $5000                   ; 7F02: FD 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    wr_mem(0x5000, A); // Care needed with I/O space and word fetches
    wr_mem(0x5001, B); 
    PC = 0x7F05; JUMP; // sstep
case 0x7F05:
                                                     mon("         LDA   #$86                    ; 7F05: 86 86         \n"); // Reg01 = Reg01 x Reg00, Reg02 = Reg02 x Reg00
    clockticks = clockticks + 2; 
    val = (UINT8)0x86; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7F07; JUMP; // sstep
case 0x7F07:
                                                     mon("         JSR   $CDBA                   ; 7F07: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x0a); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7f); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x7F0A:
                                                     mon("L7F0A    CLRB                          ; 7F0A: 5F            \n");
    B = 0; 
/**/V = 0; 
/**/Z = 0; 
/**/N = 0; 
/**/C = 0; 
    clockticks = clockticks + 2; 
    PC = 0x7F0B; JUMP; // sstep
case 0x7F0B:
                                                     mon("         LDA   $5004                   ; 7F0B: B6 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5004); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7F0E; JUMP; // sstep
case 0x7F0E:
                                                     mon("         LSRA                          ; 7F0E: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7F0F; JUMP; // sstep
case 0x7F0F:
                                                     mon("         ROLB                          ; 7F0F: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7F10; JUMP; // sstep
case 0x7F10:
                                                     mon("         LSRA                          ; 7F10: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7F11; JUMP; // sstep
case 0x7F11:
                                                     mon("         ROLB                          ; 7F11: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7F12; JUMP; // sstep
case 0x7F12:
                                                     mon("         LDA   $5002                   ; 7F12: B6 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5002); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7F15; JUMP; // sstep
case 0x7F15:
                                                     mon("         LSRA                          ; 7F15: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7F16; JUMP; // sstep
case 0x7F16:
                                                     mon("         ROLB                          ; 7F16: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7F17; JUMP; // sstep
case 0x7F17:
                                                     mon("         LSRA                          ; 7F17: 44            \n");
    val = (UINT8)A; 
    C = val & 1; 
    val = val >> 1; 
    A = val; 
/**/N = 0; 
/**/Z = val; 
    clockticks = clockticks + 2; 
    PC = 0x7F18; JUMP; // sstep
case 0x7F18:
                                                     mon("         ROLB                          ; 7F18: 59            \n");
    val = (UINT8)B; 
    res = (val << 1) + (C != 0 ?1:0); 
/**/C = res & 0x100; 
/**/Z = (UINT8)res; 
/**/N = (UINT8)res; 
/**/V = (UINT8)res ^ val; 
    B = (UINT8)res; 
    clockticks = clockticks + 2; 
    PC = 0x7F19; JUMP; // sstep
case 0x7F19:
                                                     mon("         LDA   #$08                    ; 7F19: 86 08         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x08; 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7F1B; JUMP; // sstep
case 0x7F1B:
                                                     mon("         MUL                           ; 7F1B: 3D            \n");
    res = (UINT16)(A * B); 
/**/Z = res; 
    C = res & 0x80; 
    A = res >> 8; 
    B = (UINT8)res; 
    clockticks = clockticks + 11; 
    PC = 0x7F1C; JUMP; // sstep
case 0x7F1C:
                                                     mon("         LDX   #$4C00                  ; 7F1C: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7F1F; JUMP; // sstep
case 0x7F1F:
                                                     mon("         ABX                           ; 7F1F: 3A            \n");
    X = X + B; 
    clockticks = clockticks + 3; 
    PC = 0x7F20; JUMP; // sstep
case 0x7F20:
                                                     mon("         LDD   $02,X                   ; 7F20: EC 02         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(X + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
    Z = A|B; 
    N = A; 
    V = 0; 
    PC = 0x7F22; JUMP; // sstep
case 0x7F22:
                                                     mon("         BNE   $7F28                   ; 7F22: 26 04         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x7f28; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7F24; JUMP; // sstep
case 0x7F24:
                                                     mon("         STU   $02,X                   ; 7F24: EF 02         \n");
    clockticks = clockticks + 5; 
    val = U; 
    Z = val; 
    N = (UINT8)(val >> 8); 
    V = 0; 
    ea = (X + 0x0002); 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7F26; JUMP; // sstep
case 0x7F26:
                                                     mon("         BRA   $7F2A                   ; 7F26: 20 02         \n");
    PC = 0x7f2a; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x7F28:
                                                     mon("L7F28    STU   [,X]                    ; 7F28: EF 94         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 2; 
    clockticks = clockticks + 1; 
    ea = rd_mem(X)<<8; 
    ea = ea | rd_mem((UINT16)((X)+1)); 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = ea; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7F2A; JUMP; // sstep
case 0x7F2A:
                                                     mon("L7F2A    STU   ,X                      ; 7F2A: EF 84         \n");
    clockticks = clockticks + 4; 
    val = U; 
/**/Z = val; 
/**/N = (UINT8)(val >> 8); 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, (UINT8)(val >> 8)); // Care needed with I/O space and word fetches
    wr_mem((UINT16)(ea + 1), (UINT8)val); 
    PC = 0x7F2C; JUMP; // sstep
case 0x7F2C:
                                                     mon("         LDD   #$00                    ; 7F2C: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F2F; JUMP; // sstep
case 0x7F2F:
                                                     mon("         STD   ,U                      ; 7F2F: ED C4         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = U; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7F31; JUMP; // sstep
case 0x7F31:
                                                     mon("         LDD   $5004                   ; 7F31: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F34; JUMP; // sstep
case 0x7F34:
                                                     mon("         SUBD  $06,X                   ; 7F34: A3 06         \n");
    clockticks = clockticks + 1; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0006))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0006))+1)); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7F36; JUMP; // sstep
case 0x7F36:
                                                     mon("         ANDA  #$1F                    ; 7F36: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7F38; JUMP; // sstep
case 0x7F38:
                                                     mon("         STD   $04,U                   ; 7F38: ED 44         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7F3A; JUMP; // sstep
case 0x7F3A:
                                                     mon("         LDD   $5002                   ; 7F3A: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F3D; JUMP; // sstep
case 0x7F3D:
                                                     mon("         SUBD  $04,X                   ; 7F3D: A3 04         \n");
    clockticks = clockticks + 1; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0004))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0004))+1)); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg - val; 
/**/C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ val) & (arg ^ res)) >> 8; 
    A = (UINT8)(res >> 8); 
/**/N = res >> 8; 
    B = (UINT8)res; 
    PC = 0x7F3F; JUMP; // sstep
case 0x7F3F:
                                                     mon("         ANDA  #$1F                    ; 7F3F: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7F41; JUMP; // sstep
case 0x7F41:
                                                     mon("         CMPU  $02,X                   ; 7F41: 11 A3 02      \n");
    clockticks = clockticks + 2; 
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0002))+1)); 
    val = U; 
    arg = ea; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7F44; JUMP; // sstep
case 0x7F44:
                                                     mon("         BEQ   $7F48                   ; 7F44: 27 02         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x7f48; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7F46; JUMP; // sstep
case 0x7F46:
                                                     mon("         ORA   #$00                    ; 7F46: 8A 00         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0x00; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7F48; JUMP; // sstep
case 0x7F48:
                                                     mon("L7F48    STD   $02,U                   ; 7F48: ED 42         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(U + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7F4A; JUMP; // sstep
case 0x7F4A:
                                                     mon("         LDD   $5004                   ; 7F4A: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F4D; JUMP; // sstep
case 0x7F4D:
                                                     mon("         STD   $06,X                   ; 7F4D: ED 06         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0006); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7F4F; JUMP; // sstep
case 0x7F4F:
                                                     mon("         LDD   $5002                   ; 7F4F: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F52; JUMP; // sstep
case 0x7F52:
                                                     mon("         STD   $04,X                   ; 7F52: ED 04         \n");
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = (UINT16)(X + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7F54; JUMP; // sstep
case 0x7F54:
                                                     mon("         LEAU  $06,U                   ; 7F54: 33 46         \n");
    clockticks = clockticks + 5; 
    U = (U + 0x0006); 
    PC = 0x7F56; JUMP; // sstep
case 0x7F56:
                                                     mon("         BRA   $7F5D                   ; 7F56: 20 05         \n");
    PC = 0x7f5d; 
    JUMP;
    clockticks = clockticks + 3; 
    
    // ---------------------------------------------------------------------------
  case 0x7F58:
                                                     mon("L7F58    LDX   <$84                    ; 7F58: 9E 84         \n"); // Towers surface dots
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x84)<<8; 
    ea = ea | rd_mem(DP|0x85); 
    X = ea; 
    Z = X; 
    N = (X) >> 8; 
    V = 0; 
    PC = 0x7F5A; JUMP; // sstep
case 0x7F5A:
                                                     mon("         JSR   L7FDB                   ; 7F5A: BD 7F DB      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x5d); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7f); 
    clockticks = clockticks + 1; 
    PC = 0x7fdb; 
    JUMP;
  case 0x7F5D:
                                                     mon("L7F5D    INC   <$82                    ; 7F5D: 0C 82         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x82); 
    res = (UINT8)(val + 1); 
/**/Z = res; 
/**/N = res; 
/**/V = res & ~val; 
    wr_mem(DP|0x82, res); 
    clockticks = clockticks + 2; 
    PC = 0x7F5F; JUMP; // sstep
case 0x7F5F:
                                                     mon("         LDX   <$84                    ; 7F5F: 9E 84         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(DP|0x84)<<8; 
    ea = ea | rd_mem(DP|0x85); 
    X = ea; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7F61; JUMP; // sstep
case 0x7F61:
                                                     mon("         LEAX  $08,X                   ; 7F61: 30 08         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0008); 
/**/Z = X; 
    PC = 0x7F63; JUMP; // sstep
case 0x7F63:
                                                     mon("         DEC   <$81                    ; 7F63: 0A 81         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x81); 
    res = (UINT8)(val - 1); 
    N = res; 
    Z = res; 
    V = val & ~res; 
    wr_mem(DP|0x81, res); 
    clockticks = clockticks + 2; 
    PC = 0x7F65; JUMP; // sstep
case 0x7F65:
                                                     mon("         LBNE  $7ED6                   ; 7F65: 10 26 FF 6D   \n");
    clockticks = clockticks + 5; 
    if (Z) {
    clockticks = clockticks + 1; 
    PC = 0x7ed6; 
    JUMP;
    }
    PC = 0x7F69; JUMP; // sstep
case 0x7F69:
                                                     mon("         LDX   #$4C00                  ; 7F69: 8E 4C 00      \n");
    clockticks = clockticks + 3; 
    X = 0x4c00; 
/**/Z = X; 
/**/N = (X) >> 8; 
/**/V = 0; 
    PC = 0x7F6C; JUMP; // sstep
case 0x7F6C:
                                                     mon("L7F6C    LDU   $02,X                   ; 7F6C: EE 02         \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    ea = rd_mem((UINT16)(X + 0x0002))<<8; 
    ea = ea | rd_mem((UINT16)(((UINT16)(X + 0x0002))+1)); 
    U = ea; 
    Z = U; 
    N = (U) >> 8; 
    V = 0; 
    PC = 0x7F6E; JUMP; // sstep
case 0x7F6E:
                                                     mon("         BEQ   $7F92                   ; 7F6E: 27 22         \n");
    // temp fix to ensure flags synched
    if (!Z) {
    PC = 0x7f92; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7F70; JUMP; // sstep
case 0x7F70:
                                                     mon("         LDD   #$FF98                  ; 7F70: CC FF 98      \n");
    clockticks = clockticks + 3; 
    A = 0xff; 
    B = 0x98; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F73; JUMP; // sstep
case 0x7F73:
                                                     mon("         ANDA  #$1F                    ; 7F73: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7F75; JUMP; // sstep
case 0x7F75:
                                                     mon("         STD   ,Y++                    ; 7F75: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F77; JUMP; // sstep
case 0x7F77:
                                                     mon("         LDD   #$00                    ; 7F77: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F7A; JUMP; // sstep
case 0x7F7A:
                                                     mon("         STD   ,Y++                    ; 7F7A: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F7C; JUMP; // sstep
case 0x7F7C:
                                                     mon("L7F7C    LDD   $04,U                   ; 7F7C: EC 44         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(U + 0x0004); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F7E; JUMP; // sstep
case 0x7F7E:
                                                     mon("         STD   ,Y++                    ; 7F7E: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F80; JUMP; // sstep
case 0x7F80:
                                                     mon("         LDD   $02,U                   ; 7F80: EC 42         \n");
    clockticks = clockticks + 5; 
    ea = (UINT16)(U + 0x0002); 
    A = rd_mem(ea); // Care needed with I/O space and word fetches
    B = rd_mem((UINT16)(ea+1)); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F82; JUMP; // sstep
case 0x7F82:
                                                     mon("         STD   ,Y++                    ; 7F82: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F84; JUMP; // sstep
case 0x7F84:
                                                     mon("         LDD   $33DC                   ; 7F84: FC 33 DC      \n"); // JSRL to Vector ROM subroutine to draw dot
    clockticks = clockticks + 5; 
    A = rd_mem(0x33dc); // Care needed with I/O space and word fetches
    B = rd_mem(0x33dd); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F87; JUMP; // sstep
case 0x7F87:
                                                     mon("         STD   ,Y++                    ; 7F87: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F89; JUMP; // sstep
case 0x7F89:
                                                     mon("         LDU   ,U                      ; 7F89: EE C4         \n");
    clockticks = clockticks + 4; 
    clockticks = clockticks + 1; 
    ea = rd_mem(U)<<8; 
    ea = ea | rd_mem((UINT16)((U)+1)); 
    U = ea; 
    Z = U; 
    N = (U) >> 8; 
    V = 0; 
    PC = 0x7F8B; JUMP; // sstep
case 0x7F8B:
                                                     mon("         BNE   $7F7C                   ; 7F8B: 26 EF         \n");
    // temp fix to ensure flags synched
    if (Z) {
    PC = 0x7f7c; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7F8D; JUMP; // sstep
case 0x7F8D:
                                                     mon("         LDD   #$8040                  ; 7F8D: CC 80 40      \n"); // Insert Vector CNTR
    clockticks = clockticks + 3; 
    A = 0x80; 
    B = 0x40; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7F90; JUMP; // sstep
case 0x7F90:
                                                     mon("         STD   ,Y++                    ; 7F90: ED A1         \n");
    clockticks = clockticks + 7; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = Y; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    Y = Y + 2; 
    PC = 0x7F92; JUMP; // sstep
case 0x7F92:
                                                     mon("L7F92    LEAX  $08,X                   ; 7F92: 30 08         \n");
    clockticks = clockticks + 5; 
    X = (X + 0x0008); 
/**/Z = X; 
    PC = 0x7F94; JUMP; // sstep
case 0x7F94:
                                                     mon("         CMPX  #$4C80                  ; 7F94: 8C 4C 80      \n");
    clockticks = clockticks + 4; 
    val = X; 
    arg = 0x4c80; 
    res = val - arg; 
    C = res & 0x10000; 
    res = (UINT16)res; 
    Z = res; 
    N = res >> 8; 
    V = ((val ^ arg) & (val ^ res)) >> 8; 
    PC = 0x7F97; JUMP; // sstep
case 0x7F97:
                                                     mon("         BCS   $7F6C                   ; 7F97: 25 D3         \n");
    // temp fix to ensure flags synched
    if (C) {
    PC = 0x7f6c; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    // End of function sub_7EAF
    PC = 0x7F99; JUMP; // sstep
case 0x7F99:
                                                     mon("         RTS                           ; 7F99: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7F9A:
                                                     mon("L7F9A    JSR   $CE45                   ; 7F9A: BD CE 45      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0x9d); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7f); 
    clockticks = clockticks + 1; 
    PC = 0xce45; 
    JUMP;
  case 0x7F9D:
                                                     mon("L7F9D    LDA   <$53                    ; 7F9D: 96 53         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x53); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7F9F; JUMP; // sstep
case 0x7F9F:
                                                     mon("         ANDA  #$1F                    ; 7F9F: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FA1; JUMP; // sstep
case 0x7FA1:
                                                     mon("         LDB   <$54                    ; 7FA1: D6 54         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x54); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FA3; JUMP; // sstep
case 0x7FA3:
                                                     mon("         STD   ,X                      ; 7FA3: ED 84         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FA5; JUMP; // sstep
case 0x7FA5:
                                                     mon("         MUL                           ; 7FA5: 3D            \n");
    res = (UINT16)(A * B); 
/**/Z = res; 
    C = res & 0x80; 
    A = res >> 8; 
    B = (UINT8)res; 
    clockticks = clockticks + 11; 
    PC = 0x7FA6; JUMP; // sstep
case 0x7FA6:
                                                     mon("         TST   $5002                   ; 7FA6: 7D 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5002); 
    Z = val; 
    N = val; 
    V = 0; 
    clockticks = clockticks + 2; 
    PC = 0x7FA9; JUMP; // sstep
case 0x7FA9:
                                                     mon("         BMI   $7FAC                   ; 7FA9: 2B 01         \n");
    // temp fix to ensure flags synched
    if ((SINT8)N <  0) {
    PC = 0x7fac; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7FAB; JUMP; // sstep
case 0x7FAB:
                                                     mon("         NEGA                          ; 7FAB: 40            \n");
    val = (UINT8)A; 
    res = -val; 
/**/V = val & (UINT8)res; 
/**/C = res & 0x100; 
    val = (UINT8)res; 
    A = val; 
/**/Z = val; 
/**/N = val; 
    clockticks = clockticks + 2; 
    PC = 0x7FAC; JUMP; // sstep
case 0x7FAC:
                                                     mon("L7FAC    STD   $02,X                   ; 7FAC: ED 02         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FAE; JUMP; // sstep
case 0x7FAE:
                                                     mon("         LDA   <$53                    ; 7FAE: 96 53         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x53); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FB0; JUMP; // sstep
case 0x7FB0:
                                                     mon("         ANDA  #$1F                    ; 7FB0: 84 1F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x1f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FB2; JUMP; // sstep
case 0x7FB2:
                                                     mon("         LDB   <$55                    ; 7FB2: D6 55         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x55); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FB4; JUMP; // sstep
case 0x7FB4:
                                                     mon("         MUL                           ; 7FB4: 3D            \n");
    res = (UINT16)(A * B); 
/**/Z = res; 
    C = res & 0x80; 
    A = res >> 8; 
    B = (UINT8)res; 
    clockticks = clockticks + 11; 
    PC = 0x7FB5; JUMP; // sstep
case 0x7FB5:
                                                     mon("         TST   $5004                   ; 7FB5: 7D 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5004); 
    Z = val; 
    N = val; 
    V = 0; 
    clockticks = clockticks + 2; 
    PC = 0x7FB8; JUMP; // sstep
case 0x7FB8:
                                                     mon("         BMI   $7FBB                   ; 7FB8: 2B 01         \n");
    // temp fix to ensure flags synched
    if ((SINT8)N <  0) {
    PC = 0x7fbb; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7FBA; JUMP; // sstep
case 0x7FBA:
                                                     mon("         NEGA                          ; 7FBA: 40            \n");
    val = (UINT8)A; 
    res = -val; 
/**/V = val & (UINT8)res; 
    C = res & 0x100; 
    val = (UINT8)res; 
    A = val; 
/**/Z = val; 
/**/N = val; 
    clockticks = clockticks + 2; 
    PC = 0x7FBB; JUMP; // sstep
case 0x7FBB:
                                                     mon("L7FBB    STD   $04,X                   ; 7FBB: ED 04         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FBD; JUMP; // sstep
case 0x7FBD:
                                                     mon("         LDA   <$82                    ; 7FBD: 96 82         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x82); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FBF; JUMP; // sstep
case 0x7FBF:
                                                     mon("         STA   $4702                   ; 7FBF: B7 47 02      \n");
    clockticks = clockticks + 5; 
    val = A; 
/**/Z = val; 
/**/N = val; 
/**/V = 0; 
    wr_mem(0x4702, val); 
    PC = 0x7FC2; JUMP; // sstep
case 0x7FC2:
                                                     mon("         LDA   #$60                    ; 7FC2: 86 60         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)0x60; 
    A = val; 
    N = val; 
    Z = val; 
    V = 0; 
    PC = 0x7FC4; JUMP; // sstep
case 0x7FC4:
                                                     mon("         JSR   $CDBA                   ; 7FC4: BD CD BA      \n");
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xc7); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7f); 
    clockticks = clockticks + 1; 
    PC = 0xcdba; 
    JUMP;
  case 0x7FC7:
                                                     mon("L7FC7    LDD   $5000                   ; 7FC7: FC 50 00      \n"); // Math result X
    clockticks = clockticks + 5; 
    A = rd_mem(0x5000); // Care needed with I/O space and word fetches
    B = rd_mem(0x5001); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7FCA; JUMP; // sstep
case 0x7FCA:
                                                     mon("         STD   ,X                      ; 7FCA: ED 84         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FCC; JUMP; // sstep
case 0x7FCC:
                                                     mon("         LDD   $5002                   ; 7FCC: FC 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    A = rd_mem(0x5002); // Care needed with I/O space and word fetches
    B = rd_mem(0x5003); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7FCF; JUMP; // sstep
case 0x7FCF:
                                                     mon("         STD   $02,X                   ; 7FCF: ED 02         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FD1; JUMP; // sstep
case 0x7FD1:
                                                     mon("         LDD   $5004                   ; 7FD1: FC 50 04      \n"); // Math result Z
    clockticks = clockticks + 5; 
    A = rd_mem(0x5004); // Care needed with I/O space and word fetches
    B = rd_mem(0x5005); 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7FD4; JUMP; // sstep
case 0x7FD4:
                                                     mon("         ANDA  #$FF                    ; 7FD4: 84 FF         \n"); // These 2 lines do nothing ?
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0xff; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FD6; JUMP; // sstep
case 0x7FD6:
                                                     mon("         ANDB  #$FF                    ; 7FD6: C4 FF         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)B; 
    res = val & (SINT8)0xff; 
    B = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FD8; JUMP; // sstep
case 0x7FD8:
                                                     mon("         STD   $04,X                   ; 7FD8: ED 04         \n");
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = (UINT16)(X + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    // End of function sub_7F9A
    PC = 0x7FDA; JUMP; // sstep
case 0x7FDA:
                                                     mon("         RTS                           ; 7FDA: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
    // =============== S U B R O U T I N E =======================================
  case 0x7FDB:
                                                     mon("L7FDB    JSR   $CE45                   ; 7FDB: BD CE 45      \n"); // Random number update
    clockticks = clockticks + 8; 
    S = S - 1; 
    wr_mem(S, 0xde); 
    clockticks = clockticks + 1; 
    S = S - 1; 
    wr_mem(S, 0x7f); 
    clockticks = clockticks + 1; 
    PC = 0xce45; 
    JUMP;
  case 0x7FDE:
                                                     mon("L7FDE    LDA   <$53                    ; 7FDE: 96 53         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x53); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FE0; JUMP; // sstep
case 0x7FE0:
                                                     mon("         ANDA  #$7F                    ; 7FE0: 84 7F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x7f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FE2; JUMP; // sstep
case 0x7FE2:
                                                     mon("         ORA   #$70                    ; 7FE2: 8A 70         \n");
    clockticks = clockticks + 2; 
    res = A | (UINT8)0x70; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FE4; JUMP; // sstep
case 0x7FE4:
                                                     mon("         LDB   <$54                    ; 7FE4: D6 54         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x54); 
    B = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FE6; JUMP; // sstep
case 0x7FE6:
                                                     mon("         ADDD  $5040                   ; 7FE6: F3 50 40      \n"); // XT2
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5040)<<8; 
    ea = ea | rd_mem(0x5041); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg + val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x7FE9; JUMP; // sstep
case 0x7FE9:
                                                     mon("         STD   ,X                      ; 7FE9: ED 84         \n");
    clockticks = clockticks + 4; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = X; 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FEB; JUMP; // sstep
case 0x7FEB:
                                                     mon("         LDA   <$55                    ; 7FEB: 96 55         \n");
    clockticks = clockticks + 4; 
    val = (UINT8)rd_mem(DP|0x55); 
    A = val; 
/**/N = val; 
/**/Z = val; 
/**/V = 0; 
    PC = 0x7FED; JUMP; // sstep
case 0x7FED:
                                                     mon("         ANDA  #$7F                    ; 7FED: 84 7F         \n");
    clockticks = clockticks + 2; 
    val = (UINT8)A; 
    res = val & (SINT8)0x7f; 
    A = res; 
/**/Z = res; 
/**/N = res; 
/**/V = 0; 
    PC = 0x7FEF; JUMP; // sstep
case 0x7FEF:
                                                     mon("         TST   $5002                   ; 7FEF: 7D 50 02      \n"); // Math result Y
    clockticks = clockticks + 5; 
    val = (UINT8)rd_mem(0x5002); 
    Z = val; 
    N = val; 
    V = 0; 
    clockticks = clockticks + 2; 
    PC = 0x7FF2; JUMP; // sstep
case 0x7FF2:
                                                     mon("         BMI   $7FF5                   ; 7FF2: 2B 01         \n");
    // temp fix to ensure flags synched
    if ((SINT8)N <  0) {
    PC = 0x7ff5; 
    JUMP;
    }
    clockticks = clockticks + 3; 
    PC = 0x7FF4; JUMP; // sstep
case 0x7FF4:
                                                     mon("         NEGA                          ; 7FF4: 40            \n");
    val = (UINT8)A; 
    res = -val; 
/**/V = val & (UINT8)res; 
/**/C = res & 0x100; 
    val = (UINT8)res; 
    A = val; 
/**/Z = val; 
/**/N = val; 
    clockticks = clockticks + 2; 
    PC = 0x7FF5; JUMP; // sstep
case 0x7FF5:
                                                     mon("L7FF5    ADDD  $5042                   ; 7FF5: F3 50 42      \n"); // YT2
    clockticks = clockticks + 6; 
    clockticks = clockticks + 1; 
    ea = rd_mem(0x5042)<<8; 
    ea = ea | rd_mem(0x5043); 
    val = ea; 
    arg = (A << 8) | B; 
    res = arg + val; 
    C = res & 0x10000; 
    res = (UINT16)res; 
/**/Z = res; 
/**/V = ((arg ^ res) & (val ^ res)) >> 8; 
/**/N = res >> 8; 
    A = (UINT8)(res >> 8); 
    B = (UINT8)res; 
    PC = 0x7FF8; JUMP; // sstep
case 0x7FF8:
                                                     mon("         STD   $02,X                   ; 7FF8: ED 02         \n");
    clockticks = clockticks + 5; 
/**/Z = A | B; 
/**/N = A; 
/**/V = 0; 
    ea = (UINT16)(X + 0x0002); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    PC = 0x7FFA; JUMP; // sstep
case 0x7FFA:
                                                     mon("         LDD   #$00                    ; 7FFA: CC 00 00      \n");
    clockticks = clockticks + 3; 
    A = 0x00; 
    B = 0x00; 
/**/Z = A|B; 
/**/N = A; 
/**/V = 0; 
    PC = 0x7FFD; JUMP; // sstep
case 0x7FFD:
                                                     mon("         STD   $04,X                   ; 7FFD: ED 04         \n");
    clockticks = clockticks + 5; 
    Z = A | B; 
    N = A; 
    V = 0; 
    ea = (UINT16)(X + 0x0004); 
    wr_mem(ea, A); // Care needed with I/O space and word fetches
    wr_mem(ea + 1, B); 
    // End of function sub_7FDB
    // end of 'ROM'
    PC = 0x7FFF; JUMP; // sstep
case 0x7FFF:
                                                     mon("         RTS                           ; 7FFF: 39            \n");
    clockticks = clockticks + 5; 
    clockticks = clockticks + 1; 
    PC = rd_mem(S)<<8; 
    S = S + 1; 
    PC = PC | rd_mem(S); 
    S = S + 1; 
    JUMP;
    
