This is the default output, with timing on each instruction plus a return to
the control loop after every instruction.  This is the least efficient version
and is mainly for comparing against a known emulator as it executes instruction
by instruction.

// =============== 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;
    
