unsigned short PC=0x7CE0;
unsigned short NMISTART=0x7851;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef FALSE
#define TRUE (0==0)
#define FALSE (0!=0)
#endif

#include "deluxe.h"

FILE *show;
FILE *memtrace;

unsigned short temp;
unsigned char value;
unsigned char vtmp;
unsigned char xram[0x8000];

int saveflags;

unsigned short currpc;
unsigned long instcount;

int tcount=0;

unsigned char S; // Not used enough to be worth forcing in a register

void game ( unsigned short opadd,
            unsigned char *_p,
            unsigned char *_a,
            unsigned char *_x,
            unsigned char *_y,
            unsigned long *_clockticks)
{
                                     // GCC Extension here to allow nested procedures.
                                     // Which we could avoid by making all these into macros
// Reason is to allow all these regs to be made 'register' on host system

/* Here is what we need to use!:
   4.34.2 Specifying Registers for Local Variables
   You can define a local register variable with a specified register
   like this:

   register int *foo asm ("a5");

   Here a5 is the name of the register which should be used. Note that
   this is the same syntax used for defining global register variables,
   but for a local variable it would appear within a function.
 */

#ifdef OPT_ARM
register unsigned char A asm ("r4"); // *Must* slave these to regs
register unsigned char P;
register   signed char ZN asm ("r6");  // special flag handling
register unsigned char X asm ("r7"); // And these if enough free regs
register unsigned char Y asm ("r8"); // And these if enough free regs
                  long clockticks;   // Was important; less so now...
         unsigned char C;
register unsigned char *ram asm ("r5");
         unsigned char *stack;
#else
#ifdef OPT_X86
register unsigned char A asm("%al"); // *Must* slave these to regs
         unsigned char P;
           signed char ZN;  // special flag handling
         unsigned char X; // And these if enough free regs
         unsigned char Y; // And these if enough free regs
                  long clockticks;   // Was important; less so now...
         unsigned char C;
         unsigned char *ram;
         unsigned char *stack;
#else
register unsigned char A; // *Must* slave these to regs
         unsigned char P;
           signed char ZN;  // special flag handling
         unsigned char X; // And these if enough free regs
         unsigned char Y; // And these if enough free regs
                  long clockticks;   // Was important; less so now...
         unsigned char C;
         unsigned char *ram;
         unsigned char *stack;
#endif
#endif

inline void crash ( unsigned short opadd, unsigned char opcode )
{
    printf("CRASH %04X %02X\n",opadd,opcode);
    exit(0);
}

#ifdef DEBUG

#define trace_PC(opadd) \
  do {                                                                              \
    unsigned char opcode = ram[opadd]; /* Actually rom[] */                         \
    currpc=opadd;                                                                   \
    if (0)                                                                          \
    {                                                                               \
        fprintf(show,"%04X: ",opadd);                                               \
        fprintf(show,"%02X ",opcode);                                               \
        /* Can use __LINE__, __FILE__ here if wanted... */                          \
        fprintf(show," A %02X  X %02X  Y %02X  P %02X  %04X\n",A,X,Y,P,clockticks); \
    }                                                                               \
    instcount++;                                                                    \
    if (instcount>5000000) exit(0);                                                 \
  } while (0)
 
#else

#define trace_PC(opadd) /* Nothing */

#endif

// NOTE!!!  because poll_nmi is like a subroutine call,
// every occurance of poll_nmi must be followed by a label on
// the next statement, otherwise when we eliminate redundant
// labels, the return from interrupt will no be able to
// know where to go.  Fortunately we only ever now plant
// these calls at branch instructions etc, so we conveniently
// have those labels available!  (Some care still needs
// to be taken as to exactly where the call is placed, eg
// what if the instruction is "JMP elsewhere" followed by data...)

static int nmi_count = 0;

#define poll_nmi(opadd) \
  do {                                                                                           \
    if (clockticks>250)                                                                          \
    {                                                                                            \
        clockticks-=250;                                                                         \
        ram [0x2001] ^= 0xff;  /* Because clocktick resolution is now coarser, this */           \
                               /* soft timer is no longer cycle-accurate - may be 10% off... */  \
        if (++nmi_count == 24)                                                                   \
        {                                                                                        \
            nmi_count = 0;                                                                       \
            stack[S--] = (unsigned char)((opadd>>8)&0x7F);                                       \
            stack[S--] = (unsigned char)(opadd&0xFF);                                            \
            stack[S--] = P;                                                                      \
            P |= 0x04; /* Interrupt mode flag */                                                 \
            PC=NMISTART;                                                                         \
            /*    do_keys (); */                                                                 \
        }                                                                                        \
    }                                                                                            \
  } while (0)

#define DO_N(val)  do { if ((val) & 0x80) P |= 0x80; else P &= 0x7f; } while (0)
#define DO_Z(val)  do { if ((val)) P &= 0xfd;        else P |= 0x02; } while (0)
#define DO_ZN(val) do { if ((val) & 0x80) P |= 0x80; else P &= 0x7f; \
                        if ((val)) P &= 0xfd;        else P |= 0x02; } while (0)

#define ADC(value) \
  do {                                                           \
    int carry;                                                   \
    vtmp = value ^ A;                                            \
    carry = P & 0x01;                                            \
    if (P & 0x08) {                                              \
      int ah = A & 0xf0;                                         \
      int al = A & 0x0f;                                         \
      int oh = value & 0xf0;                                     \
      int ol = value & 0x0f;                                     \
      al += ol + carry;                                          \
      if (al >= 0x0a) { al -= 0x0a; ah += 0x10; }                \
      ah += oh;                                                  \
      if (ah >= 0xa0) { ah -= 0xa0; P |= 0x01; }                 \
      else P &= 0xfe;                                            \
      A = ah | al;                                               \
    } else {                                                     \
      int sum= A + value + carry;                                \
      if (sum>0xff) P |= 0x01; else P &= 0xfe;                   \
      A = sum;                                                   \
      clockticks++;                                              \
    }                                                            \
    if ((vtmp ^ A ^ (P << 7)) & 0x80) P |= 0x40; else P &= 0xbf; \
    DO_Z (A);                                                    \
    DO_N (A);                                                    \
  } while (0)

#define SBC(value) \
  do {                                                           \
    int borrow;                                                  \
    vtmp = value ^ A;                                            \
    borrow = !(P & 0x01);                                        \
    if (P & 0x08) {                                              \
      int ah = A & 0xf0;                                         \
      int al = A & 0x0f;                                         \
      int oh = value & 0xf0;                                     \
      int ol = value & 0x0f;                                     \
      al -= (ol + borrow);                                       \
      if (al < 0) { al += 0x0a; ah -= 0x10; }                    \
      ah -= oh;                                                  \
      if (ah < 0) { ah += 0xa0; P &= 0xfe; }                     \
      else P |= 0x01;                                            \
      A = ah | al;                                               \
    } else {                                                     \
      int sum= A - value - borrow;                               \
      if (sum>=0) P |= 0x01; else P &= 0xfe;                     \
      A = sum;                                                   \
      clockticks++;                                              \
    }                                                            \
    if ((vtmp ^ A ^ (P << 7)) & 0x80) P &= 0xbf; else P |= 0x40; \
    DO_Z (A);                                                    \
    DO_N (A);                                                    \
  } while (0)



    ram = &xram[0];
    stack = &xram[0x100];
    P = *_p; A = *_a; X = *_x; Y = *_y; clockticks = *_clockticks;

    switch(opadd)
    {

        default:
            printf("CASE %04X not defined -  we could kick in an emulator here...\n",opadd);
            printf("Anyway... modify 'hitlist' to add this address as code and a jump target\n");
            exit(0);

//---- THIS IS THE LAST LINE IN GTOP.C ----
/* 000 [def:0001] [use:0001] */      case 0x4800: L_4800: //B9 00 02
/* 001 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4800);
/* 004 [def:0001] [use:0001] */      case 0x4803: L_4803: //29 3C 4A
/* 005 [def:0009] [use:0008] */          A &= 0x3C;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4803);
/* 008 [def:0001] [use:0001] */      case 0x4805: L_4805: //4A 4A AA
/* 009 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 010 [def:0009] [use:0008] */          A = A >> 1;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4805);
/* 013 [def:0001] [use:0001] */      case 0x4806: L_4806: //4A AA BD
/* 014 [def:2001] [use:0008] */          C = A & 0x01;
/* 015 [def:0009] [use:0008] */          A = A >> 1;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4806);
/* 018 [def:0001] [use:0001] */      case 0x4807: L_4807: //AA BD F8
/* 019 [def:0011] [use:0008] */          X=A;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x4807);
/* 022 [def:0001] [use:0001] */      case 0x4808: L_4808: //BD F8 02
/* 023 [def:0009] [use:0011] */          A=ram[0x02F8 + X /* can't wrap */];
/* 024 [def:1801] [use:0008] */          ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x4808);
/* 026 [def:0001] [use:0001] */      case 0x480B: L_480b: //10 31 86
/* 027 [def:0001] [use:1001] */          if (ZN < 0)
/* 028 [def:0001] [use:0001] */          {
/* 029 [def:0001] [use:0001] */              //trace_PC(0x480B);
/* 030 [def:0001] [use:0001] */              PC = 0x483e;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x480B);
/* 002 [def:0001] [use:0001] */      case 0x480D: L_480d: //86 1A A9
/* 003 [def:0001] [use:0001] */          ram[0x001A] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x480D);
/* 005 [def:0001] [use:0001] */      case 0x480F: L_480f: //A9 05 20
/* 006 [def:0009] [use:0000] */          A=0x05;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x480F);
/* 009 [def:0001] [use:0001] */      case 0x4811: L_4811: //20 B2 48
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x13;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4811);
/* 013 [def:0001] [use:0001] */          PC = 0x48b2;
/*                           */          clockticks += 30; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4814: L_4814: //20 50 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x16;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4814);
/* 004 [def:0001] [use:0001] */          PC = 0x6d50;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4817: L_4817: //EE E7 02
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4817);
/* 003 [def:0001] [use:0001] */      case 0x481A: L_481a: //B9 00 02
/* 004 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x481A);
/* 007 [def:0001] [use:0001] */      case 0x481D: L_481d: //48 20 EB
/* 008 [def:0001] [use:0001] */          stack[S--] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x481D);
/* 010 [def:0001] [use:0001] */      case 0x481E: L_481e: //20 EB 61
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x20;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x481E);
/* 014 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4821: L_4821: //68 9D 00
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4821);
/* 004 [def:0001] [use:0001] */      case 0x4822: L_4822: //9D 00 02
/* 005 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4822);
/* 007 [def:0001] [use:0001] */      case 0x4825: L_4825: //A9 00 99
/* 008 [def:0008] [use:0000] */  //      A=0x00;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4825);
/* 011 [def:0001] [use:0001] */      case 0x4827: L_4827: //99 00 02
/* 012 [def:0001] [use:0021] */          ram[(unsigned short)(0x0200 + Y)] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4827);
/* 014 [def:0001] [use:0001] */      case 0x482A: L_482a: //A6 1A BD
/* 015 [def:0001] [use:0001] */          X=ram[0x001A];
/* 016 [def:1800] [use:0010] */  //      ZN = X;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x482A);
/* 018 [def:0001] [use:0001] */      case 0x482C: L_482c: //BD F8 02
/* 019 [def:0009] [use:0011] */          A=ram[0x02F8 + X /* can't wrap */];
/* 020 [def:1801] [use:0008] */          ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x482C);
/* 022 [def:0001] [use:0001] */      case 0x482F: L_482f: //10 1D 48
/* 023 [def:0001] [use:1001] */          if (ZN < 0)
/* 024 [def:0001] [use:0001] */          {
/* 025 [def:0001] [use:0001] */              //trace_PC(0x482F);
/* 026 [def:0001] [use:0001] */              PC = 0x484e;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x482F);
/* 002 [def:0001] [use:0001] */      case 0x4831: L_4831: //48 A9 7F
/* 003 [def:0001] [use:0001] */          stack[S--] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4831);
/* 005 [def:0001] [use:0001] */      case 0x4832: L_4832: //A9 7F 9D
/* 006 [def:0009] [use:0000] */          A=0x7F;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4832);
/* 009 [def:0001] [use:0001] */      case 0x4834: L_4834: //9D F8 02
/* 010 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4834);
/* 012 [def:0001] [use:0001] */      case 0x4837: L_4837: //68 4A 29
/* 013 [def:0001] [use:0001] */          A=stack[++S];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x4837);
/* 016 [def:0001] [use:0001] */      case 0x4838: L_4838: //4A 29 0F
/* 017 [def:2001] [use:0008] */          C = A & 0x01;
/* 018 [def:0009] [use:0008] */          A = A >> 1;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4838);
/* 021 [def:0001] [use:0001] */      case 0x4839: L_4839: //29 0F AA
/* 022 [def:0009] [use:0008] */          A &= 0x0F;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x4839);
/* 025 [def:0001] [use:0001] */      case 0x483B: L_483b: //AA 10 EE
/* 026 [def:0011] [use:0008] */          X=A;
/* 027 [def:1801] [use:0008] */          ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x483B);
/* 029 [def:0001] [use:0001] */      case 0x483C: L_483c: //10 EE 4A
/* 030 [def:0001] [use:1001] */          if (ZN < 0)
/* 031 [def:0001] [use:0001] */          {
/* 032 [def:0001] [use:0001] */              //trace_PC(0x483C);
/* 033 [def:0001] [use:0001] */              PC = 0x482c;
/*                           */              clockticks += 51;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x483C);
/* 002 [def:0001] [use:0001] */      case 0x483E: L_483e: //4A B0 10
/* 003 [def:2001] [use:0008] */          C = A & 0x01;
/* 004 [def:0009] [use:0008] */          A = A >> 1;
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x483E);
/* 007 [def:0001] [use:0001] */      case 0x483F: L_483f: //B0 10 A9
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x483F);
/* 011 [def:0001] [use:0001] */              PC = 0x4851;
/*                           */              clockticks += 55;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x483F);
/* 002 [def:0001] [use:0001] */      case 0x4841: L_4841: //A9 00 9D
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4841);
/* 006 [def:0001] [use:0001] */      case 0x4843: L_4843: //9D F8 02
/* 007 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4843);
/* 009 [def:0001] [use:0001] */      case 0x4846: L_4846: //A9 20 20
/* 010 [def:0009] [use:0000] */          A=0x20;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4846);
/* 013 [def:0001] [use:0001] */      case 0x4848: L_4848: //20 B2 48
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4848);
/* 017 [def:0001] [use:0001] */          PC = 0x48b2;
/*                           */          clockticks += 71; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x484B: L_484b: //20 AC 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x4D;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x484B);
/* 004 [def:0001] [use:0001] */          PC = 0x49ac;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x484E: L_484e: //A6 0E 60
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x484E);
/* 004 [def:0001] [use:0001] */      case 0x4850: L_4850: //60 A9 10
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4850);
/* 006 [def:0001] [use:0001] */          PC=stack[++S];
/* 007 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 008 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4851: L_4851: //A9 10 86
/* 001 [def:0009] [use:0000] */          A=0x10;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4851);
/* 004 [def:0001] [use:0001] */      case 0x4853: L_4853: //86 1A 20
/* 005 [def:0001] [use:0001] */          ram[0x001A] = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4853);
/* 007 [def:0001] [use:0001] */      case 0x4855: L_4855: //20 B2 48
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x57;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4855);
/* 011 [def:0001] [use:0001] */          PC = 0x48b2;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4858: L_4858: //20 50 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x5A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4858);
/* 004 [def:0001] [use:0001] */          PC = 0x6d50;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x485B: L_485b: //20 EB 61
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x5D;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x485B);
/* 004 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x485E: L_485e: //EE E7 02
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x485E);
/* 003 [def:0001] [use:0001] */      case 0x4861: L_4861: //EE FF 02
/* 004 [def:1801] [use:0001] */          ZN=++ram[0x02FF];
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4861);
/* 006 [def:0001] [use:0001] */      case 0x4864: L_4864: //A5 1A 0A
/* 007 [def:0009] [use:0001] */          A=ram[0x001A];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4864);
/* 010 [def:0001] [use:0001] */      case 0x4866: L_4866: //0A 0A 09
/* 011 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 012 [def:0009] [use:0008] */          A = A << 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4866);
/* 015 [def:0001] [use:0001] */      case 0x4867: L_4867: //0A 09 42
/* 016 [def:2001] [use:0008] */          C = A & 0x80;
/* 017 [def:0009] [use:0008] */          A = A << 1;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x4867);
/* 020 [def:0001] [use:0001] */      case 0x4868: L_4868: //09 42 9D
/* 021 [def:0001] [use:0001] */          A |= 0x42;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4868);
/* 024 [def:0001] [use:0001] */      case 0x486A: L_486a: //9D 00 02
/* 025 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x486A);
/* 027 [def:0001] [use:0001] */      case 0x486D: L_486d: //86 10 A6
/* 028 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x486D);
/* 030 [def:0001] [use:0001] */      case 0x486F: L_486f: //A6 1A A9
/* 031 [def:0001] [use:0001] */          X=ram[0x001A];
/* 032 [def:1800] [use:0010] */  //      ZN = X;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x486F);
/* 034 [def:0001] [use:0001] */      case 0x4871: L_4871: //A9 7E 9D
/* 035 [def:0009] [use:0000] */          A=0x7E;
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x4871);
/* 038 [def:0001] [use:0001] */      case 0x4873: L_4873: //9D F8 02
/* 039 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x4873);
/* 041 [def:0001] [use:0001] */      case 0x4876: L_4876: //A5 79 69
/* 042 [def:0009] [use:0001] */          A=ram[0x0079];
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x4876);
/* 045 [def:0001] [use:0001] */      case 0x4878: L_4878: //69 20 9D
/* 046 [def:b801] [use:6001] */          ADC(0x20);
/* 047 [def:0001] [use:0001] */          //trace_PC(0x4878);
/* 048 [def:0001] [use:0001] */      case 0x487A: L_487a: //9D F1 02
/* 049 [def:0001] [use:0019] */          ram[0x02F1 + X /* can't wrap */] = A;
/* 050 [def:0001] [use:0001] */          //trace_PC(0x487A);
/* 051 [def:0001] [use:0001] */      case 0x487D: L_487d: //20 A7 48
/* 052 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 053 [def:0001] [use:0001] */          stack[S--] = 0x7F;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x487D);
/* 055 [def:0001] [use:0001] */          PC = 0x48a7;
/*                           */          clockticks += 57; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4880: L_4880: //86 1A A6
/* 001 [def:0001] [use:0001] */          ram[0x001A] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4880);
/* 003 [def:0001] [use:0001] */      case 0x4882: L_4882: //A6 10 20
/* 004 [def:0001] [use:0001] */          X=ram[0x0010];
/* 005 [def:1801] [use:0010] */          ZN = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4882);
/* 007 [def:0001] [use:0001] */      case 0x4884: L_4884: //20 52 6D
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x86;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4884);
/* 011 [def:0001] [use:0001] */          PC = 0x6d52;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4887: L_4887: //20 EB 61
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x89;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4887);
/* 004 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x488A: L_488a: //EE E7 02
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x488A);
/* 003 [def:0001] [use:0001] */      case 0x488D: L_488d: //A5 1A 0A
/* 004 [def:0009] [use:0001] */          A=ram[0x001A];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x488D);
/* 007 [def:0001] [use:0001] */      case 0x488F: L_488f: //0A 0A 09
/* 008 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 009 [def:0009] [use:0008] */          A = A << 1;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x488F);
/* 012 [def:0001] [use:0001] */      case 0x4890: L_4890: //0A 09 42
/* 013 [def:2001] [use:0008] */          C = A & 0x80;
/* 014 [def:0009] [use:0008] */          A = A << 1;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4890);
/* 017 [def:0001] [use:0001] */      case 0x4891: L_4891: //09 42 9D
/* 018 [def:0001] [use:0001] */          A |= 0x42;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4891);
/* 021 [def:0001] [use:0001] */      case 0x4893: L_4893: //9D 00 02
/* 022 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4893);
/* 024 [def:0001] [use:0001] */      case 0x4896: L_4896: //A6 1A A9
/* 025 [def:0001] [use:0001] */          X=ram[0x001A];
/* 026 [def:1800] [use:0010] */  //      ZN = X;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x4896);
/* 028 [def:0001] [use:0001] */      case 0x4898: L_4898: //A9 7E 9D
/* 029 [def:0009] [use:0000] */          A=0x7E;
/* 030 [def:1800] [use:0008] */  //      ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x4898);
/* 032 [def:0001] [use:0001] */      case 0x489A: L_489a: //9D F8 02
/* 033 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x489A);
/* 035 [def:0001] [use:0001] */      case 0x489D: L_489d: //A5 79 E9
/* 036 [def:0009] [use:0001] */          A=ram[0x0079];
/* 037 [def:1800] [use:0008] */  //      ZN = A;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x489D);
/* 039 [def:0001] [use:0001] */      case 0x489F: L_489f: //E9 20 9D
/* 040 [def:b809] [use:6009] */          SBC(0x20);
/* 041 [def:0001] [use:0001] */          //trace_PC(0x489F);
/* 042 [def:0001] [use:0001] */      case 0x48A1: L_48a1: //9D F1 02
/* 043 [def:0001] [use:0019] */          ram[0x02F1 + X /* can't wrap */] = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x48A1);
/* 045 [def:0001] [use:0001] */      case 0x48A4: L_48a4: //A6 0E 60
/* 046 [def:0001] [use:0001] */          X=ram[0x000E];
/* 047 [def:1801] [use:0010] */          ZN = X;
/* 048 [def:0001] [use:0001] */          //trace_PC(0x48A4);
/* 049 [def:0001] [use:0001] */      case 0x48A6: L_48a6: //60 A2 06
/* 050 [def:0001] [use:0001] */          //trace_PC(0x48A6);
/* 051 [def:0001] [use:0001] */          PC=stack[++S];
/* 052 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 053 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 52; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x48A7: L_48a7: //A2 06 BD
/* 001 [def:0001] [use:0001] */          X=0x06;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x48A7);
/* 004 [def:0001] [use:0001] */      case 0x48A9: L_48a9: //BD F8 02
/* 005 [def:0009] [use:0011] */          A=ram[0x02F8 + X /* can't wrap */];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x48A9);
/* 008 [def:0001] [use:0001] */      case 0x48AC: L_48ac: //F0 03 CA
/* 009 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x48AC);
/* 012 [def:0001] [use:0001] */              PC = 0x48b1;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48AC);
/* 002 [def:0001] [use:0001] */      case 0x48AE: L_48ae: //CA 10 F8
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x48AE);
/* 006 [def:0001] [use:0001] */      case 0x48AF: L_48af: //10 F8 60
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x48AF);
/* 010 [def:0001] [use:0001] */              PC = 0x48a9;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48AF);
/* 002 [def:0001] [use:0001] */      case 0x48B1: L_48b1: //60 A6 0E
/* 003 [def:0001] [use:0001] */          //trace_PC(0x48B1);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x48B2: L_48b2: //A6 0E F0
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x48B2);
/* 004 [def:0001] [use:0001] */      case 0x48B4: L_48b4: //F0 04 E0
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x48B4);
/* 008 [def:0001] [use:0001] */              PC = 0x48ba;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48B4);
/* 002 [def:0001] [use:0001] */      case 0x48B6: L_48b6: //E0 04 90
/* 003 [def:0101] [use:0000] */          ZN=0x04;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x48B6);
/* 007 [def:0001] [use:0001] */      case 0x48B8: L_48b8: //90 F7 18
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x48B8);
/* 011 [def:0001] [use:0001] */              PC = 0x48b1;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48B8);
/* 002 [def:0001] [use:0001] */      case 0x48BA: L_48ba: //18 4C 44
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x48BA);
/* 005 [def:0001] [use:0001] */      case 0x48BB: L_48bb: //4C 44 6C
/* 006 [def:0001] [use:0001] */          //trace_PC(0x48BB);
/* 007 [def:0001] [use:0001] */          PC = 0x6c44;
/*                           */          clockticks += 15; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x48BE: L_48be: //86 10 A0
/* 001 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x48BE);
/* 003 [def:0001] [use:0001] */      case 0x48C0: L_48c0: //A0 19 84
/* 004 [def:0021] [use:0000] */          Y=0x19;
/* 005 [def:1800] [use:0020] */  //      ZN = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x48C0);
/* 007 [def:0001] [use:0001] */      case 0x48C2: L_48c2: //84 11 E6
/* 008 [def:0001] [use:0020] */          ram[0x0011] = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x48C2);
/* 010 [def:0001] [use:0001] */      case 0x48C4: L_48c4: //E6 19 BD
/* 011 [def:1801] [use:0001] */          ZN=++ram[0x0019];
/* 012 [def:0001] [use:0001] */          //trace_PC(0x48C4);
/* 013 [def:0001] [use:0001] */      case 0x48C6: L_48c6: //BD 00 02
/* 014 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x48C6);
/* 017 [def:0001] [use:0001] */      case 0x48C9: L_48c9: //4A 4A 29
/* 018 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 019 [def:0009] [use:0008] */          A = A >> 1;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x48C9);
/* 022 [def:0001] [use:0001] */      case 0x48CA: L_48ca: //4A 29 0F
/* 023 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 024 [def:0009] [use:0008] */          A = A >> 1;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x48CA);
/* 027 [def:0001] [use:0001] */      case 0x48CB: L_48cb: //29 0F AA
/* 028 [def:0009] [use:0008] */          A &= 0x0F;
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x48CB);
/* 031 [def:0001] [use:0001] */      case 0x48CD: L_48cd: //AA BC F8
/* 032 [def:0011] [use:0008] */          X=A;
/* 033 [def:1800] [use:0008] */  //      ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x48CD);
/* 035 [def:0001] [use:0001] */      case 0x48CE: L_48ce: //BC F8 02
/* 036 [def:0021] [use:0011] */          Y=ram[(unsigned short)(0x02F8 + X)];
/* 037 [def:1800] [use:0020] */  //      ZN = Y;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x48CE);
/* 039 [def:0001] [use:0001] */      case 0x48D1: L_48d1: //C0 04 90
/* 040 [def:0101] [use:0001] */          ZN=0x04;
/* 041 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 042 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x48D1);
/* 044 [def:0001] [use:0001] */      case 0x48D3: L_48d3: //90 1C A5
/* 045 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 046 [def:0001] [use:0001] */          {
/* 047 [def:0001] [use:0001] */              //trace_PC(0x48D3);
/* 048 [def:0001] [use:0001] */              PC = 0x48f1;
/*                           */              clockticks += 35;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48D3);
/* 002 [def:0001] [use:0001] */      case 0x48D5: L_48d5: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x48D5);
/* 006 [def:0001] [use:0001] */      case 0x48D7: L_48d7: //29 0F D0
/* 007 [def:0009] [use:0008] */          A &= 0x0F;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x48D7);
/* 010 [def:0001] [use:0001] */      case 0x48D9: L_48d9: //D0 07 98
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x48D9);
/* 014 [def:0001] [use:0001] */              PC = 0x48e2;
/*                           */              clockticks += 43;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48D9);
/* 002 [def:0001] [use:0001] */      case 0x48DB: L_48db: //98 38 E9
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x48DB);
/* 006 [def:0001] [use:0001] */      case 0x48DC: L_48dc: //38 E9 02
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x48DC);
/* 009 [def:0001] [use:0001] */      case 0x48DD: L_48dd: //E9 02 9D
/* 010 [def:b809] [use:6009] */          SBC(0x02);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x48DD);
/* 012 [def:0001] [use:0001] */      case 0x48DF: L_48df: //9D F8 02
/* 013 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x48DF);
/* 015 [def:0001] [use:0001] */      case 0x48E2: L_48e2: //AD 19 02
/* 016 [def:0009] [use:0001] */          A=ram[0x0219];
/* 017 [def:1801] [use:0008] */          ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x48E2);
/* 019 [def:0001] [use:0001] */      case 0x48E5: L_48e5: //F0 02 10
/* 020 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x48E5);
/* 023 [def:0001] [use:0001] */              PC = 0x48e9;
/*                           */              clockticks += 61;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48E5);
/* 002 [def:0001] [use:0001] */      case 0x48E7: L_48e7: //10 0A 98
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x48E7);
/* 006 [def:0001] [use:0001] */              PC = 0x48f3;
/*                           */              clockticks += 63;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x48E7);
/* 002 [def:0001] [use:0001] */      case 0x48E9: L_48e9: //98 29 01
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x48E9);
/* 006 [def:0001] [use:0001] */      case 0x48EA: L_48ea: //29 01 09
/* 007 [def:0009] [use:0008] */          A &= 0x01;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x48EA);
/* 010 [def:0001] [use:0001] */      case 0x48EC: L_48ec: //09 02 9D
/* 011 [def:0001] [use:0001] */          A |= 0x02;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x48EC);
/* 014 [def:0001] [use:0001] */      case 0x48EE: L_48ee: //9D F8 02
/* 015 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x48EE);
/* 017 [def:0001] [use:0001] */      case 0x48F1: L_48f1: //E6 11 A4
/* 018 [def:1801] [use:0001] */          ZN=++ram[0x0011];
/* 019 [def:0001] [use:0001] */          //trace_PC(0x48F1);
/* 020 [def:0001] [use:0001] */      case 0x48F3: L_48f3: //A4 11 86
/* 021 [def:0021] [use:0001] */          Y=ram[0x0011];
/* 022 [def:1800] [use:0020] */  //      ZN = Y;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x48F3);
/* 024 [def:0001] [use:0001] */      case 0x48F5: L_48f5: //86 1A A6
/* 025 [def:0001] [use:0001] */          ram[0x001A] = X;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x48F5);
/* 027 [def:0001] [use:0001] */      case 0x48F7: L_48f7: //A6 10 20
/* 028 [def:0001] [use:0001] */          X=ram[0x0010];
/* 029 [def:1801] [use:0010] */          ZN = X;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x48F7);
/* 031 [def:0001] [use:0001] */      case 0x48F9: L_48f9: //20 22 4A
/* 032 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 033 [def:0001] [use:0001] */          stack[S--] = 0xFB;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x48F9);
/* 035 [def:0001] [use:0001] */          PC = 0x4a22;
/*                           */          clockticks += 94; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x48FC: L_48fc: //20 FD 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x48;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xFE;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x48FC);
/* 004 [def:0001] [use:0001] */          PC = 0x49fd;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x48FF: L_48ff: //85 13 A5
/* 001 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x48FF);
/* 003 [def:0001] [use:0001] */      case 0x4901: L_4901: //A5 0C 85
/* 004 [def:0009] [use:0001] */          A=ram[0x000C];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4901);
/* 007 [def:0001] [use:0001] */      case 0x4903: L_4903: //85 12 A5
/* 008 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4903);
/* 010 [def:0001] [use:0001] */      case 0x4905: L_4905: //A5 11 18
/* 011 [def:0009] [use:0001] */          A=ram[0x0011];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4905);
/* 014 [def:0001] [use:0001] */      case 0x4907: L_4907: //18 69 21
/* 015 [def:2001] [use:0000] */          C = 0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4907);
/* 017 [def:0001] [use:0001] */      case 0x4908: L_4908: //69 21 A8
/* 018 [def:b801] [use:6001] */          ADC(0x21);
/* 019 [def:0001] [use:0001] */          //trace_PC(0x4908);
/* 020 [def:0001] [use:0001] */      case 0x490A: L_490a: //A8 8A 69
/* 021 [def:0021] [use:0008] */          Y=A;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x490A);
/* 024 [def:0001] [use:0001] */      case 0x490B: L_490b: //8A 69 21
/* 025 [def:0001] [use:0001] */          A=X;
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x490B);
/* 028 [def:0001] [use:0001] */      case 0x490C: L_490c: //69 21 AA
/* 029 [def:b801] [use:6001] */          ADC(0x21);
/* 030 [def:0001] [use:0001] */          //trace_PC(0x490C);
/* 031 [def:0001] [use:0001] */      case 0x490E: L_490e: //AA 20 22
/* 032 [def:0011] [use:0008] */          X=A;
/* 033 [def:1801] [use:0008] */          ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x490E);
/* 035 [def:0001] [use:0001] */      case 0x490F: L_490f: //20 22 4A
/* 036 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 037 [def:0001] [use:0001] */          stack[S--] = 0x11;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x490F);
/* 039 [def:0001] [use:0001] */          PC = 0x4a22;
/*                           */          clockticks += 30; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4912: L_4912: //20 FD 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x14;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4912);
/* 004 [def:0001] [use:0001] */          PC = 0x49fd;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4915: L_4915: //20 32 4A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x17;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4915);
/* 004 [def:0001] [use:0001] */          PC = 0x4a32;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4918: L_4918: //A6 1A 85
/* 001 [def:0001] [use:0001] */          X=ram[0x001A];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4918);
/* 004 [def:0001] [use:0001] */      case 0x491A: L_491a: //85 12 A0
/* 005 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x491A);
/* 007 [def:0001] [use:0001] */      case 0x491C: L_491c: //A0 19 C4
/* 008 [def:0021] [use:0000] */          Y=0x19;
/* 009 [def:1801] [use:0020] */          ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x491C);
/* 011 [def:0001] [use:0001] */      case 0x491E: L_491e: //C4 11 D0
/* 012 [def:0001] [use:0001] */          ZN=ram[0x0011];
/* 013 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 014 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x491E);
/* 016 [def:0001] [use:0001] */      case 0x4920: L_4920: //D0 19 49
/* 017 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x4920);
/* 020 [def:0001] [use:0001] */              PC = 0x493b;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4920);
/* 002 [def:0001] [use:0001] */      case 0x4922: L_4922: //49 80 E5
/* 003 [def:0009] [use:0008] */          A ^= 0x80;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4922);
/* 006 [def:0001] [use:0001] */      case 0x4924: L_4924: //E5 79 10
/* 007 [def:b809] [use:6009] */          SBC(ram[0x0079]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4924);
/* 009 [def:0001] [use:0001] */      case 0x4926: L_4926: //10 02 49
/* 010 [def:0001] [use:1001] */          if (ZN < 0)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x4926);
/* 013 [def:0001] [use:0001] */              PC = 0x492a;
/*                           */              clockticks += 22;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4926);
/* 002 [def:0001] [use:0001] */      case 0x4928: L_4928: //49 FF C9
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4928);
/* 006 [def:0001] [use:0001] */      case 0x492A: L_492a: //C9 10 B0
/* 007 [def:0101] [use:0000] */          ZN=0x10;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x492A);
/* 011 [def:0001] [use:0001] */      case 0x492C: L_492c: //B0 0D A5
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x492C);
/* 015 [def:0001] [use:0001] */              PC = 0x493b;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x492C);
/* 002 [def:0001] [use:0001] */      case 0x492E: L_492e: //A5 12 FD
/* 003 [def:0009] [use:0001] */          A=ram[0x0012];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x492E);
/* 006 [def:0001] [use:0001] */      case 0x4930: L_4930: //FD F1 02
/* 007 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x02F1 + X)]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4930);
/* 009 [def:0001] [use:0001] */      case 0x4933: L_4933: //10 02 49
/* 010 [def:0001] [use:1001] */          if (ZN < 0)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x4933);
/* 013 [def:0001] [use:0001] */              PC = 0x4937;
/*                           */              clockticks += 39;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4933);
/* 002 [def:0001] [use:0001] */      case 0x4935: L_4935: //49 FF C9
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4935);
/* 006 [def:0001] [use:0001] */      case 0x4937: L_4937: //C9 40 90
/* 007 [def:0101] [use:0000] */          ZN=0x40;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4937);
/* 011 [def:0001] [use:0001] */      case 0x4939: L_4939: //90 31 A5
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4939);
/* 015 [def:0001] [use:0001] */              PC = 0x496c;
/*                           */              clockticks += 47;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4939);
/* 002 [def:0001] [use:0001] */      case 0x493B: L_493b: //A5 12 38
/* 003 [def:0009] [use:0001] */          A=ram[0x0012];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x493B);
/* 006 [def:0001] [use:0001] */      case 0x493D: L_493d: //38 FD F1
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x493D);
/* 009 [def:0001] [use:0001] */      case 0x493E: L_493e: //FD F1 02
/* 010 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x02F1 + X)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x493E);
/* 012 [def:0001] [use:0001] */      case 0x4941: L_4941: //85 12 10
/* 013 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4941);
/* 015 [def:0001] [use:0001] */      case 0x4943: L_4943: //10 02 49
/* 016 [def:0001] [use:1001] */          if (ZN < 0)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x4943);
/* 019 [def:0001] [use:0001] */              PC = 0x4947;
/*                           */              clockticks += 60;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4943);
/* 002 [def:0001] [use:0001] */      case 0x4945: L_4945: //49 FF C9
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4945);
/* 006 [def:0001] [use:0001] */      case 0x4947: L_4947: //C9 08 90
/* 007 [def:0101] [use:0000] */          ZN=0x08;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4947);
/* 011 [def:0001] [use:0001] */      case 0x4949: L_4949: //90 21 A9
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4949);
/* 015 [def:0001] [use:0001] */              PC = 0x496c;
/*                           */              clockticks += 68;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4949);
/* 002 [def:0001] [use:0001] */      case 0x494B: L_494b: //A9 01 A0
/* 003 [def:0009] [use:0000] */          A=0x01;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x494B);
/* 006 [def:0001] [use:0001] */      case 0x494D: L_494d: //A0 19 C4
/* 007 [def:0021] [use:0000] */          Y=0x19;
/* 008 [def:1801] [use:0020] */          ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x494D);
/* 010 [def:0001] [use:0001] */      case 0x494F: L_494f: //C4 11 D0
/* 011 [def:0001] [use:0001] */          ZN=ram[0x0011];
/* 012 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 013 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x494F);
/* 015 [def:0001] [use:0001] */      case 0x4951: L_4951: //D0 0D A6
/* 016 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x4951);
/* 019 [def:0001] [use:0001] */              PC = 0x4960;
/*                           */              clockticks += 79;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4951);
/* 002 [def:0001] [use:0001] */      case 0x4953: L_4953: //A6 19 E0
/* 003 [def:0001] [use:0001] */          X=ram[0x0019];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4953);
/* 006 [def:0001] [use:0001] */      case 0x4955: L_4955: //E0 07 90
/* 007 [def:0101] [use:0000] */          ZN=0x07;
/* 008 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 009 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4955);
/* 011 [def:0001] [use:0001] */      case 0x4957: L_4957: //90 02 A2
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4957);
/* 015 [def:0001] [use:0001] */              PC = 0x495b;
/*                           */              clockticks += 87;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4957);
/* 002 [def:0001] [use:0001] */      case 0x495B: L_495b: //BD A4 49
/* 003 [def:0009] [use:0011] */          A=ram[0x49A4 + X /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x495B);
/* 006 [def:0001] [use:0001] */      case 0x495E: L_495e: //A6 1A 06
/* 007 [def:0001] [use:0001] */          X=ram[0x001A];
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x495E);
/* 010 [def:0001] [use:0001] */      case 0x4960: L_4960: //06 12 90
/* 011 [def:0101] [use:0001] */          ZN=ram[0x0012];
/* 012 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 013 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 014 [def:0001] [use:1800] */          ram[0x0012] = ZN; /* Because at this point it actually has the correct value in it */
/* 015 [def:0001] [use:0001] */          //trace_PC(0x4960);
/* 016 [def:0001] [use:0001] */      case 0x4962: L_4962: //90 02 49
/* 017 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x4962);
/* 020 [def:0001] [use:0001] */              PC = 0x4966;
/*                           */              clockticks += 101;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4962);
/* 002 [def:0001] [use:0001] */      case 0x4964: L_4964: //49 FF 7D
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4964);
/* 006 [def:0001] [use:0001] */      case 0x4966: L_4966: //7D F1 02
/* 007 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02F1 + X)]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4966);
/* 009 [def:0001] [use:0001] */      case 0x4969: L_4969: //9D F1 02
/* 010 [def:0001] [use:0019] */          ram[0x02F1 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4969);
/* 012 [def:0001] [use:0001] */      case 0x496C: L_496c: //AD F0 02
/* 013 [def:0009] [use:0001] */          A=ram[0x02F0];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x496C);
/* 016 [def:0001] [use:0001] */      case 0x496F: L_496f: //4A 18 65
/* 017 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 018 [def:0009] [use:0008] */          A = A >> 1;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x496F);
/* 021 [def:0001] [use:0001] */      case 0x4970: L_4970: //18 65 D3
/* 022 [def:2001] [use:0000] */          C = 0;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4970);
/* 024 [def:0001] [use:0001] */      case 0x4971: L_4971: //65 D3 0A
/* 025 [def:b801] [use:6001] */          ADC(ram[0x00D3]);
/* 026 [def:0001] [use:0001] */          //trace_PC(0x4971);
/* 027 [def:0001] [use:0001] */      case 0x4973: L_4973: //0A CD 57
/* 028 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 029 [def:0009] [use:0008] */          A = A << 1;
/* 030 [def:1800] [use:0008] */  //      ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x4973);
/* 032 [def:0001] [use:0001] */      case 0x4974: L_4974: //CD 57 69
/* 033 [def:0101] [use:0001] */          ZN=ram[0x6957];
/* 034 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 035 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x4974);
/* 037 [def:0001] [use:0001] */      case 0x4977: L_4977: //90 03 AD
/* 038 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 039 [def:0001] [use:0001] */          {
/* 040 [def:0001] [use:0001] */              //trace_PC(0x4977);
/* 041 [def:0001] [use:0001] */              PC = 0x497c;
/*                           */              clockticks += 132;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4977);
/* 002 [def:0001] [use:0001] */      case 0x497C: L_497c: //6D 58 69
/* 003 [def:b801] [use:6001] */          ADC(ram[0x6958]);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x497C);
/* 005 [def:0001] [use:0001] */      case 0x497F: L_497f: //85 11 48
/* 006 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x497F);
/* 008 [def:0001] [use:0001] */      case 0x4981: L_4981: //48 BD F1
/* 009 [def:0001] [use:0001] */          stack[S--] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4981);
/* 011 [def:0001] [use:0001] */      case 0x4982: L_4982: //BD F1 02
/* 012 [def:0009] [use:0011] */          A=ram[0x02F1 + X /* can't wrap */];
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4982);
/* 015 [def:0001] [use:0001] */      case 0x4985: L_4985: //20 FE 70
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 017 [def:0001] [use:0001] */          stack[S--] = 0x87;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x4985);
/* 019 [def:0001] [use:0001] */          PC = 0x70fe;
/*                           */          clockticks += 150; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4988: L_4988: //20 BB 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x8A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4988);
/* 004 [def:0001] [use:0001] */          PC = 0x49bb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x498B: L_498b: //A6 10 9D
/* 001 [def:0001] [use:0001] */          X=ram[0x0010];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x498B);
/* 004 [def:0001] [use:0001] */      case 0x498D: L_498d: //9D 21 02
/* 005 [def:0001] [use:0019] */          ram[0x0221 + X /* can't wrap */] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x498D);
/* 007 [def:0001] [use:0001] */      case 0x4990: L_4990: //68 85 11
/* 008 [def:0001] [use:0001] */          A=stack[++S];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4990);
/* 011 [def:0001] [use:0001] */      case 0x4991: L_4991: //85 11 A6
/* 012 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4991);
/* 014 [def:0001] [use:0001] */      case 0x4993: L_4993: //A6 1A BD
/* 015 [def:0001] [use:0001] */          X=ram[0x001A];
/* 016 [def:1800] [use:0010] */  //      ZN = X;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4993);
/* 018 [def:0001] [use:0001] */      case 0x4995: L_4995: //BD F1 02
/* 019 [def:0009] [use:0011] */          A=ram[0x02F1 + X /* can't wrap */];
/* 020 [def:1801] [use:0008] */          ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x4995);
/* 022 [def:0001] [use:0001] */      case 0x4998: L_4998: //20 01 71
/* 023 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 024 [def:0001] [use:0001] */          stack[S--] = 0x9A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x4998);
/* 026 [def:0001] [use:0001] */          PC = 0x7101;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x499B: L_499b: //20 BB 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x9D;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x499B);
/* 004 [def:0001] [use:0001] */          PC = 0x49bb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x499E: L_499e: //A6 10 9D
/* 001 [def:0001] [use:0001] */          X=ram[0x0010];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x499E);
/* 004 [def:0001] [use:0001] */      case 0x49A0: L_49a0: //9D 42 02
/* 005 [def:0001] [use:0019] */          ram[0x0242 + X /* can't wrap */] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x49A0);
/* 007 [def:0001] [use:0001] */      case 0x49A3: L_49a3: //60 01 02
/* 008 [def:0001] [use:0001] */          //trace_PC(0x49A3);
/* 009 [def:0001] [use:0001] */          PC=stack[++S];
/* 010 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 011 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x49AC: L_49ac: //CE FF 02
/* 001 [def:1801] [use:0001] */          ZN=--ram[0x02FF];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x49AC);
/* 003 [def:0001] [use:0001] */      case 0x49AF: L_49af: //D0 09 98
/* 004 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 005 [def:0001] [use:0001] */          {
/* 006 [def:0001] [use:0001] */              //trace_PC(0x49AF);
/* 007 [def:0001] [use:0001] */              PC = 0x49ba;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49AF);
/* 002 [def:0001] [use:0001] */      case 0x49B1: L_49b1: //98 48 A0
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x49B1);
/* 006 [def:0001] [use:0001] */      case 0x49B2: L_49b2: //48 A0 3F
/* 007 [def:0001] [use:0001] */          stack[S--] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x49B2);
/* 009 [def:0001] [use:0001] */      case 0x49B3: L_49b3: //A0 3F 20
/* 010 [def:0021] [use:0000] */          Y=0x3F;
/* 011 [def:1801] [use:0020] */          ZN = Y;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x49B3);
/* 013 [def:0001] [use:0001] */      case 0x49B5: L_49b5: //20 16 77
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x49;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0xB7;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x49B5);
/* 017 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x49B8: L_49b8: //68 A8 60
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x49B8);
/* 004 [def:0001] [use:0001] */      case 0x49B9: L_49b9: //A8 60 A8
/* 005 [def:0021] [use:0008] */          Y=A;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x49B9);
/* 008 [def:0001] [use:0001] */      case 0x49BA: L_49ba: //60 A8 10
/* 009 [def:0001] [use:0001] */          //trace_PC(0x49BA);
/* 010 [def:0001] [use:0001] */          PC=stack[++S];
/* 011 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 012 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x49BB: L_49bb: //A8 10 05
/* 001 [def:0021] [use:0008] */          Y=A;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x49BB);
/* 004 [def:0001] [use:0001] */      case 0x49BC: L_49bc: //10 05 49
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x49BC);
/* 008 [def:0001] [use:0001] */              PC = 0x49c3;
/*                           */              clockticks += 5;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49BC);
/* 002 [def:0001] [use:0001] */      case 0x49BE: L_49be: //49 FF 18
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x49BE);
/* 006 [def:0001] [use:0001] */      case 0x49C0: L_49c0: //18 69 01
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x49C0);
/* 009 [def:0001] [use:0001] */      case 0x49C1: L_49c1: //69 01 85
/* 010 [def:b801] [use:6001] */          ADC(0x01);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x49C1);
/* 012 [def:0001] [use:0001] */      case 0x49C3: L_49c3: //85 12 A9
/* 013 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x49C3);
/* 015 [def:0001] [use:0001] */      case 0x49C5: L_49c5: //A9 00 85
/* 016 [def:0009] [use:0000] */          A=0x00;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x49C5);
/* 019 [def:0001] [use:0001] */      case 0x49C7: L_49c7: //85 13 06
/* 020 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x49C7);
/* 022 [def:0001] [use:0001] */      case 0x49C9: L_49c9: //06 11 B0
/* 023 [def:0101] [use:0001] */          ZN=ram[0x0011];
/* 024 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 025 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 026 [def:0001] [use:1800] */          ram[0x0011] = ZN; /* Because at this point it actually has the correct value in it */
/* 027 [def:0001] [use:0001] */          //trace_PC(0x49C9);
/* 028 [def:0001] [use:0001] */      case 0x49CB: L_49cb: //B0 0D D0
/* 029 [def:0001] [use:2001] */          if (C)
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x49CB);
/* 032 [def:0001] [use:0001] */              PC = 0x49da;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49CB);
/* 002 [def:0001] [use:0001] */      case 0x49CD: L_49cd: //D0 12 A5
/* 003 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x49CD);
/* 006 [def:0001] [use:0001] */              PC = 0x49e1;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49CD);
/* 002 [def:0001] [use:0001] */      case 0x49CF: L_49cf: //A5 13 C0
/* 003 [def:0009] [use:0001] */          A=ram[0x0013];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x49CF);
/* 006 [def:0001] [use:0001] */      case 0x49D1: L_49d1: //C0 00 10
/* 007 [def:0101] [use:0001] */          ZN=0x00;
/* 008 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 009 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x49D1);
/* 011 [def:0001] [use:0001] */      case 0x49D3: L_49d3: //10 04 49
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x49D3);
/* 015 [def:0001] [use:0001] */              PC = 0x49d9;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49D3);
/* 002 [def:0001] [use:0001] */      case 0x49D5: L_49d5: //49 FF 69
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x49D5);
/* 006 [def:0001] [use:0001] */      case 0x49D7: L_49d7: //69 00 60
/* 007 [def:b801] [use:6001] */          ADC(0x00);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x49D7);
/* 009 [def:0001] [use:0001] */      case 0x49D9: L_49d9: //60 A5 13
/* 010 [def:0001] [use:0001] */          //trace_PC(0x49D9);
/* 011 [def:0001] [use:0001] */          PC=stack[++S];
/* 012 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 013 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 48; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x49DA: L_49da: //A5 13 18
/* 001 [def:0009] [use:0001] */          A=ram[0x0013];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x49DA);
/* 004 [def:0001] [use:0001] */      case 0x49DC: L_49dc: //18 65 12
/* 005 [def:2001] [use:0000] */          C = 0;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x49DC);
/* 007 [def:0001] [use:0001] */      case 0x49DD: L_49dd: //65 12 85
/* 008 [def:b801] [use:6001] */          ADC(ram[0x0012]);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x49DD);
/* 010 [def:0001] [use:0001] */      case 0x49DF: L_49df: //85 13 46
/* 011 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x49DF);
/* 013 [def:0001] [use:0001] */      case 0x49E1: L_49e1: //46 12 D0
/* 014 [def:0101] [use:0001] */          ZN=ram[0x0012];
/* 015 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 016 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 017 [def:0001] [use:0100] */          ram[0x0012] = ZN;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x49E1);
/* 019 [def:0001] [use:0001] */      case 0x49E3: L_49e3: //D0 E4 F0
/* 020 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x49E3);
/* 023 [def:0001] [use:0001] */              PC = 0x49c9;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49E3);
/* 002 [def:0001] [use:0001] */      case 0x49E5: L_49e5: //F0 E8 C9
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x49E5);
/* 006 [def:0001] [use:0001] */              PC = 0x49cf;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49E5);
/* 002 [def:0001] [use:0001] */      case 0x49E7: L_49e7: //C9 10 90
/* 003 [def:0101] [use:0000] */          ZN=0x10;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x49E7);
/* 007 [def:0001] [use:0001] */      case 0x49E9: L_49e9: //90 11 C9
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x49E9);
/* 011 [def:0001] [use:0001] */              PC = 0x49fc;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49E9);
/* 002 [def:0001] [use:0001] */      case 0x49EB: L_49eb: //C9 F0 B0
/* 003 [def:0101] [use:0000] */          ZN=0xF0;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x49EB);
/* 007 [def:0001] [use:0001] */      case 0x49ED: L_49ed: //B0 0D 85
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x49ED);
/* 011 [def:0001] [use:0001] */              PC = 0x49fc;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49ED);
/* 002 [def:0001] [use:0001] */      case 0x49EF: L_49ef: //85 15 A9
/* 003 [def:0001] [use:0008] */          ram[0x0015] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x49EF);
/* 005 [def:0001] [use:0001] */      case 0x49F1: L_49f1: //A9 00 38
/* 006 [def:0009] [use:0000] */          A=0x00;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x49F1);
/* 009 [def:0001] [use:0001] */      case 0x49F3: L_49f3: //38 E5 0C
/* 010 [def:2001] [use:0000] */          C = 1;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x49F3);
/* 012 [def:0001] [use:0001] */      case 0x49F4: L_49f4: //E5 0C 85
/* 013 [def:b809] [use:6009] */          SBC(ram[0x000C]);
/* 014 [def:0001] [use:0001] */          //trace_PC(0x49F4);
/* 015 [def:0001] [use:0001] */      case 0x49F6: L_49f6: //85 0C A9
/* 016 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x49F6);
/* 018 [def:0001] [use:0001] */      case 0x49F8: L_49f8: //A9 00 E5
/* 019 [def:0009] [use:0000] */          A=0x00;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x49F8);
/* 022 [def:0001] [use:0001] */      case 0x49FA: L_49fa: //E5 15 60
/* 023 [def:b809] [use:6009] */          SBC(ram[0x0015]);
/* 024 [def:0001] [use:0001] */          //trace_PC(0x49FA);
/* 025 [def:0001] [use:0001] */      case 0x49FC: L_49fc: //60 C9 04
/* 026 [def:0001] [use:0001] */          //trace_PC(0x49FC);
/* 027 [def:0001] [use:0001] */          PC=stack[++S];
/* 028 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 029 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 53; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x49FD: L_49fd: //C9 04 90
/* 001 [def:0101] [use:0000] */          ZN=0x04;
/* 002 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 003 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x49FD);
/* 005 [def:0001] [use:0001] */      case 0x49FF: L_49ff: //90 FB C9
/* 006 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x49FF);
/* 009 [def:0001] [use:0001] */              PC = 0x49fc;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x49FF);
/* 002 [def:0001] [use:0001] */      case 0x4A01: L_4a01: //C9 FC B0
/* 003 [def:0101] [use:0000] */          ZN=0xFC;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4A01);
/* 007 [def:0001] [use:0001] */      case 0x4A03: L_4a03: //B0 F7 A4
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x4A03);
/* 011 [def:0001] [use:0001] */              PC = 0x49fc;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A03);
/* 002 [def:0001] [use:0001] */      case 0x4A05: L_4a05: //A4 D3 C0
/* 003 [def:0021] [use:0001] */          Y=ram[0x00D3];
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A05);
/* 006 [def:0001] [use:0001] */      case 0x4A07: L_4a07: //C0 05 90
/* 007 [def:0101] [use:0001] */          ZN=0x05;
/* 008 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 009 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4A07);
/* 011 [def:0001] [use:0001] */      case 0x4A09: L_4a09: //90 DC A4
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4A09);
/* 015 [def:0001] [use:0001] */              PC = 0x49e7;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A09);
/* 002 [def:0001] [use:0001] */      case 0x4A22: L_4a22: //B9 A5 02
/* 003 [def:0009] [use:0021] */          A=ram[0x02A5 + Y /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A22);
/* 006 [def:0001] [use:0001] */      case 0x4A25: L_4a25: //38 FD A5
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4A25);
/* 009 [def:0001] [use:0001] */      case 0x4A26: L_4a26: //FD A5 02
/* 010 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x02A5 + X)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4A26);
/* 012 [def:0001] [use:0001] */      case 0x4A29: L_4a29: //85 0C B9
/* 013 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4A29);
/* 015 [def:0001] [use:0001] */      case 0x4A2B: L_4a2b: //B9 63 02
/* 016 [def:0009] [use:0021] */          A=ram[0x0263 + Y /* can't wrap */];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x4A2B);
/* 019 [def:0001] [use:0001] */      case 0x4A2E: L_4a2e: //FD 63 02
/* 020 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x0263 + X)]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x4A2E);
/* 022 [def:0001] [use:0001] */      case 0x4A31: L_4a31: //60 85 14
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4A31);
/* 024 [def:0001] [use:0001] */          PC=stack[++S];
/* 025 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 026 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 44; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4A32: L_4a32: //85 14 10
/* 001 [def:0001] [use:0008] */          ram[0x0014] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4A32);
/* 003 [def:0001] [use:0001] */      case 0x4A34: L_4a34: //10 03 20
/* 004 [def:0001] [use:1001] */          if (ZN < 0)
/* 005 [def:0001] [use:0001] */          {
/* 006 [def:0001] [use:0001] */              //trace_PC(0x4A34);
/* 007 [def:0001] [use:0001] */              PC = 0x4a39;
/*                           */              clockticks += 5;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A34);
/* 002 [def:0001] [use:0001] */      case 0x4A36: L_4a36: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x38;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A36);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 10; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4A39: L_4a39: //85 15 A5
/* 001 [def:0001] [use:0008] */          ram[0x0015] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4A39);
/* 003 [def:0001] [use:0001] */      case 0x4A3B: L_4a3b: //A5 13 10
/* 004 [def:0009] [use:0001] */          A=ram[0x0013];
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4A3B);
/* 007 [def:0001] [use:0001] */      case 0x4A3D: L_4a3d: //10 03 20
/* 008 [def:0001] [use:1001] */          if (ZN < 0)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x4A3D);
/* 011 [def:0001] [use:0001] */              PC = 0x4a42;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A3D);
/* 002 [def:0001] [use:0001] */      case 0x4A3F: L_4a3f: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x41;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A3F);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4A42: L_4a42: //05 15 A2
/* 001 [def:0009] [use:0009] */          A|=ram[0x0015];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4A42);
/* 004 [def:0001] [use:0001] */      case 0x4A44: L_4a44: //A2 07 0A
/* 005 [def:0001] [use:0001] */          X=0x07;
/* 006 [def:1800] [use:0010] */  //      ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4A44);
/* 008 [def:0001] [use:0001] */      case 0x4A46: L_4a46: //0A 30 03
/* 009 [def:2001] [use:0008] */          C = A & 0x80;
/* 010 [def:0009] [use:0008] */          A = A << 1;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4A46);
/* 013 [def:0001] [use:0001] */      case 0x4A47: L_4a47: //30 03 CA
/* 014 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x4A47);
/* 017 [def:0001] [use:0001] */              PC = 0x4a4c;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A47);
/* 002 [def:0001] [use:0001] */      case 0x4A49: L_4a49: //CA D0 FA
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A49);
/* 006 [def:0001] [use:0001] */      case 0x4A4A: L_4a4a: //D0 FA E0
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x4A4A);
/* 010 [def:0001] [use:0001] */              PC = 0x4a46;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A4A);
/* 002 [def:0001] [use:0001] */      case 0x4A4C: L_4a4c: //E0 04 B0
/* 003 [def:0101] [use:0000] */          ZN=0x04;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4A4C);
/* 007 [def:0001] [use:0001] */      case 0x4A4E: L_4a4e: //B0 12 46
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x4A4E);
/* 011 [def:0001] [use:0001] */              PC = 0x4a62;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A4E);
/* 002 [def:0001] [use:0001] */      case 0x4A50: L_4a50: //46 13 66
/* 003 [def:0101] [use:0001] */          ZN=ram[0x0013];
/* 004 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 005 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 006 [def:0001] [use:0100] */          ram[0x0013] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4A50);
/* 008 [def:0001] [use:0001] */      case 0x4A52: L_4a52: //66 12 46
/* 009 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 010 [def:0101] [use:0001] */          ZN=ram[0x0012];
/* 011 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 012 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 013 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 014 [def:0001] [use:0100] */          ram[0x0012] = ZN;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x4A52);
/* 016 [def:0001] [use:0001] */      case 0x4A54: L_4a54: //46 14 66
/* 017 [def:0101] [use:0001] */          ZN=ram[0x0014];
/* 018 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 019 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 020 [def:0001] [use:0100] */          ram[0x0014] = ZN;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x4A54);
/* 022 [def:0001] [use:0001] */      case 0x4A56: L_4a56: //66 0C CA
/* 023 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 024 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 025 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 026 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 027 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 028 [def:0001] [use:0100] */          ram[0x000C] = ZN;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x4A56);
/* 030 [def:0001] [use:0001] */      case 0x4A58: L_4a58: //CA 10 F5
/* 031 [def:0011] [use:0010] */          X--;
/* 032 [def:1801] [use:0010] */          ZN = X;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x4A58);
/* 034 [def:0001] [use:0001] */      case 0x4A59: L_4a59: //10 F5 A6
/* 035 [def:0001] [use:1001] */          if (ZN < 0)
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x4A59);
/* 038 [def:0001] [use:0001] */              PC = 0x4a50;
/*                           */              clockticks += 44;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A59);
/* 002 [def:0001] [use:0001] */      case 0x4A5B: L_4a5b: //A6 12 A4
/* 003 [def:0001] [use:0001] */          X=ram[0x0012];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A5B);
/* 006 [def:0001] [use:0001] */      case 0x4A5D: L_4a5d: //A4 0C 4C
/* 007 [def:0021] [use:0001] */          Y=ram[0x000C];
/* 008 [def:1801] [use:0020] */          ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4A5D);
/* 010 [def:0001] [use:0001] */      case 0x4A5F: L_4a5f: //4C 9E 70
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4A5F);
/* 012 [def:0001] [use:0001] */          PC = 0x709e;
/*                           */          clockticks += 52; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4A62: L_4a62: //06 12 26
/* 001 [def:0101] [use:0001] */          ZN=ram[0x0012];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 003 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 004 [def:0001] [use:1800] */          ram[0x0012] = ZN; /* Because at this point it actually has the correct value in it */
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A62);
/* 006 [def:0001] [use:0001] */      case 0x4A64: L_4a64: //26 13 06
/* 007 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 008 [def:0101] [use:0001] */          ZN=ram[0x0013];
/* 009 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 010 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 011 [def:1801] [use:10100] */          ZN |= saveflags;
/* 012 [def:0001] [use:1800] */          ram[0x0013] = ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4A64);
/* 014 [def:0001] [use:0001] */      case 0x4A66: L_4a66: //06 0C 26
/* 015 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 016 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 017 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 018 [def:0001] [use:1800] */          ram[0x000C] = ZN; /* Because at this point it actually has the correct value in it */
/* 019 [def:0001] [use:0001] */          //trace_PC(0x4A66);
/* 020 [def:0001] [use:0001] */      case 0x4A68: L_4a68: //26 14 E8
/* 021 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 022 [def:0101] [use:0001] */          ZN=ram[0x0014];
/* 023 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 024 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 025 [def:1801] [use:10100] */          ZN |= saveflags;
/* 026 [def:0001] [use:1800] */          ram[0x0014] = ZN;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x4A68);
/* 028 [def:0001] [use:0001] */      case 0x4A6A: L_4a6a: //E8 E0 07
/* 029 [def:0011] [use:0010] */          X++;
/* 030 [def:1800] [use:0010] */  //      ZN = X;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x4A6A);
/* 032 [def:0001] [use:0001] */      case 0x4A6B: L_4a6b: //E0 07 90
/* 033 [def:0101] [use:0000] */          ZN=0x07;
/* 034 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 035 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x4A6B);
/* 037 [def:0001] [use:0001] */      case 0x4A6D: L_4a6d: //90 F3 A6
/* 038 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 039 [def:0001] [use:0001] */          {
/* 040 [def:0001] [use:0001] */              //trace_PC(0x4A6D);
/* 041 [def:0001] [use:0001] */              PC = 0x4a62;
/*                           */              clockticks += 28;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A6D);
/* 002 [def:0001] [use:0001] */      case 0x4A6F: L_4a6f: //A6 13 A4
/* 003 [def:0001] [use:0001] */          X=ram[0x0013];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A6F);
/* 006 [def:0001] [use:0001] */      case 0x4A71: L_4a71: //A4 14 B0
/* 007 [def:0021] [use:0001] */          Y=ram[0x0014];
/* 008 [def:1801] [use:0020] */          ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4A71);
/* 010 [def:0001] [use:0001] */      case 0x4A73: L_4a73: //B0 EA 4A
/* 011 [def:0001] [use:2001] */          if (C)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x4A73);
/* 014 [def:0001] [use:0001] */              PC = 0x4a5f;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A73);
/* 002 [def:0001] [use:0001] */      case 0x4A75: L_4a75: //4A 4A 4A
/* 003 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 004 [def:0009] [use:0008] */          A = A >> 1;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4A75);
/* 007 [def:0001] [use:0001] */      case 0x4A76: L_4a76: //4A 4A 29
/* 008 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 009 [def:0009] [use:0008] */          A = A >> 1;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4A76);
/* 012 [def:0001] [use:0001] */      case 0x4A77: L_4a77: //4A 29 0F
/* 013 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 014 [def:0009] [use:0008] */          A = A >> 1;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4A77);
/* 017 [def:0001] [use:0001] */      case 0x4A78: L_4a78: //29 0F AA
/* 018 [def:0009] [use:0008] */          A &= 0x0F;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4A78);
/* 021 [def:0001] [use:0001] */      case 0x4A7A: L_4a7a: //AA BD F8
/* 022 [def:0011] [use:0008] */          X=A;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x4A7A);
/* 025 [def:0001] [use:0001] */      case 0x4A7B: L_4a7b: //BD F8 02
/* 026 [def:0009] [use:0011] */          A=ram[0x02F8 + X /* can't wrap */];
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x4A7B);
/* 029 [def:0001] [use:0001] */      case 0x4A7E: L_4a7e: //4A A9 00
/* 030 [def:2001] [use:0008] */          C = A & 0x01;
/* 031 [def:0008] [use:0008] */  //      A = A >> 1;
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x4A7E);
/* 034 [def:0001] [use:0001] */      case 0x4A7F: L_4a7f: //A9 00 6A
/* 035 [def:0009] [use:0000] */          A=0x00;
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x4A7F);
/* 038 [def:0001] [use:0001] */      case 0x4A81: L_4a81: //6A 6A 85
/* 039 [def:10001] [use:2000] */          saveflags = C;
/* 040 [def:2001] [use:0008] */          C = A & 0x01;
/* 041 [def:0009] [use:0008] */          A = A >> 1;
/* 042 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x4A81);
/* 045 [def:0001] [use:0001] */      case 0x4A82: L_4a82: //6A 85 11
/* 046 [def:10001] [use:2000] */          saveflags = C;
/* 047 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 048 [def:0009] [use:0008] */          A = A >> 1;
/* 049 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x4A82);
/* 052 [def:0001] [use:0001] */      case 0x4A83: L_4a83: //85 11 BD
/* 053 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x4A83);
/* 055 [def:0001] [use:0001] */      case 0x4A85: L_4a85: //BD F1 02
/* 056 [def:0009] [use:0011] */          A=ram[0x02F1 + X /* can't wrap */];
/* 057 [def:1800] [use:0008] */  //      ZN = A;
/* 058 [def:0001] [use:0001] */          //trace_PC(0x4A85);
/* 059 [def:0001] [use:0001] */      case 0x4A88: L_4a88: //4A 4A 24
/* 060 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 061 [def:0009] [use:0008] */          A = A >> 1;
/* 062 [def:1800] [use:0008] */  //      ZN = A;
/* 063 [def:0001] [use:0001] */          //trace_PC(0x4A88);
/* 064 [def:0001] [use:0001] */      case 0x4A89: L_4a89: //4A 24 11
/* 065 [def:2001] [use:0008] */          C = A & 0x01;
/* 066 [def:0009] [use:0008] */          A = A >> 1;
/* 067 [def:1800] [use:0008] */  //      ZN = A;
/* 068 [def:0001] [use:0001] */          //trace_PC(0x4A89);
/* 069 [def:0001] [use:0001] */      case 0x4A8A: L_4a8a: //24 11 50
/* 070 [def:1101] [use:0001] */          ZN=ram[0x0011];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 071 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 072 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 073 [def:0001] [use:0001] */          //trace_PC(0x4A8A);
/* 074 [def:0001] [use:0001] */      case 0x4A8C: L_4a8c: //50 02 29
/* 075 [def:0001] [use:8000] */          if ((P & 0x40) == 0) /* BVC */
/* 076 [def:0001] [use:0001] */          {
/* 077 [def:0001] [use:0001] */              //trace_PC(0x4A8C);
/* 078 [def:0001] [use:0001] */              PC = 0x4a90;
/*                           */              clockticks += 75;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4A8C);
/* 002 [def:0001] [use:0001] */      case 0x4A8E: L_4a8e: //29 1E 29
/* 003 [def:0009] [use:0008] */          A &= 0x1E;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4A8E);
/* 006 [def:0001] [use:0001] */      case 0x4A90: L_4a90: //29 3E 05
/* 007 [def:0009] [use:0008] */          A &= 0x3E;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4A90);
/* 010 [def:0001] [use:0001] */      case 0x4A92: L_4a92: //05 11 A8
/* 011 [def:0009] [use:0009] */          A|=ram[0x0011];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4A92);
/* 014 [def:0001] [use:0001] */      case 0x4A94: L_4a94: //A8 BE 2B
/* 015 [def:0021] [use:0008] */          Y=A;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4A94);
/* 018 [def:0001] [use:0001] */      case 0x4A95: L_4a95: //BE 2B 50
/* 019 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x502B + Y)];
/* 020 [def:1800] [use:0010] */  //      ZN = X;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x4A95);
/* 022 [def:0001] [use:0001] */      case 0x4A98: L_4a98: //B9 2A 50
/* 023 [def:0009] [use:0021] */          A=ram[0x502A + Y /* can't wrap */];
/* 024 [def:1801] [use:0008] */          ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x4A98);
/* 026 [def:0001] [use:0001] */      case 0x4A9B: L_4a9b: //4C D5 7C
/* 027 [def:0001] [use:0001] */          //trace_PC(0x4A9B);
/* 028 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 96; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4A9E: L_4a9e: //AD F0 02
/* 001 [def:0009] [use:0001] */          A=ram[0x02F0];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4A9E);
/* 004 [def:0001] [use:0001] */      case 0x4AA1: L_4aa1: //F0 13 18
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x4AA1);
/* 008 [def:0001] [use:0001] */              PC = 0x4ab6;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AA1);
/* 002 [def:0001] [use:0001] */      case 0x4AA3: L_4aa3: //18 A2 02
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4AA3);
/* 005 [def:0001] [use:0001] */      case 0x4AA4: L_4aa4: //A2 02 69
/* 006 [def:0001] [use:0001] */          X=0x02;
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4AA4);
/* 009 [def:0001] [use:0001] */      case 0x4AA6: L_4aa6: //69 02 C9
/* 010 [def:b801] [use:6001] */          ADC(0x02);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4AA6);
/* 012 [def:0001] [use:0001] */      case 0x4AA8: L_4aa8: //C9 05 90
/* 013 [def:0101] [use:0000] */          ZN=0x05;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4AA8);
/* 017 [def:0001] [use:0001] */      case 0x4AAA: L_4aaa: //90 03 E8
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x4AAA);
/* 021 [def:0001] [use:0001] */              PC = 0x4aaf;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AAA);
/* 002 [def:0001] [use:0001] */      case 0x4AAC: L_4aac: //E8 A9 05
/* 003 [def:0011] [use:0010] */          X++;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4AAC);
/* 006 [def:0001] [use:0001] */      case 0x4AAD: L_4aad: //A9 05 86
/* 007 [def:0009] [use:0000] */          A=0x05;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4AAD);
/* 010 [def:0001] [use:0001] */      case 0x4AAF: L_4aaf: //86 11 CD
/* 011 [def:0001] [use:0001] */          ram[0x0011] = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4AAF);
/* 013 [def:0001] [use:0001] */      case 0x4AB1: L_4ab1: //CD E7 02
/* 014 [def:0101] [use:0001] */          ZN=ram[0x02E7];
/* 015 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 016 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4AB1);
/* 018 [def:0001] [use:0001] */      case 0x4AB4: L_4ab4: //B0 01 60
/* 019 [def:0001] [use:2001] */          if (C)
/* 020 [def:0001] [use:0001] */          {
/* 021 [def:0001] [use:0001] */              //trace_PC(0x4AB4);
/* 022 [def:0001] [use:0001] */              PC = 0x4ab7;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AB4);
/* 002 [def:0001] [use:0001] */      case 0x4AB6: L_4ab6: //60 AE FF
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4AB6);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 38; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4AB7: L_4ab7: //AE FF 02
/* 001 [def:0001] [use:0001] */          X=ram[0x02FF];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4AB7);
/* 004 [def:0001] [use:0001] */      case 0x4ABA: L_4aba: //D0 FA AC
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x4ABA);
/* 008 [def:0001] [use:0001] */              PC = 0x4ab6;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4ABA);
/* 002 [def:0001] [use:0001] */      case 0x4ABC: L_4abc: //AC E7 02
/* 003 [def:0001] [use:0001] */          Y=ram[0x02E7];
/* 004 [def:0001] [use:0001] */          DO_Z (Y);
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4ABC);
/* 006 [def:0001] [use:0001] */      case 0x4ABF: L_4abf: //BD 00 02
/* 007 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4ABF);
/* 010 [def:0001] [use:0001] */      case 0x4AC2: L_4ac2: //D0 02 86
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x4AC2);
/* 014 [def:0001] [use:0001] */              PC = 0x4ac6;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AC2);
/* 002 [def:0001] [use:0001] */      case 0x4AC4: L_4ac4: //86 10 10
/* 003 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4AC4);
/* 005 [def:0001] [use:0001] */      case 0x4AC6: L_4ac6: //10 01 88
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x4AC6);
/* 009 [def:0001] [use:0001] */              PC = 0x4ac9;
/*                           */              clockticks += 21;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AC6);
/* 002 [def:0001] [use:0001] */      case 0x4AC8: L_4ac8: //88 E8 E0
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4AC8);
/* 006 [def:0001] [use:0001] */      case 0x4AC9: L_4ac9: //E8 E0 19
/* 007 [def:0011] [use:0010] */          X++;
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4AC9);
/* 010 [def:0001] [use:0001] */      case 0x4ACA: L_4aca: //E0 19 90
/* 011 [def:0101] [use:0000] */          ZN=0x19;
/* 012 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 013 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4ACA);
/* 015 [def:0001] [use:0001] */      case 0x4ACC: L_4acc: //90 F1 A6
/* 016 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x4ACC);
/* 019 [def:0001] [use:0001] */              PC = 0x4abf;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4ACC);
/* 002 [def:0001] [use:0001] */      case 0x4ACE: L_4ace: //A6 1E B5
/* 003 [def:0001] [use:0001] */          X=ram[0x001E];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4ACE);
/* 006 [def:0001] [use:0001] */      case 0x4AD0: L_4ad0: //B5 D1 F0
/* 007 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xd1 + X)];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4AD0);
/* 010 [def:0001] [use:0001] */      case 0x4AD2: L_4ad2: //F0 04 C4
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x4AD2);
/* 014 [def:0001] [use:0001] */              PC = 0x4ad8;
/*                           */              clockticks += 39;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AD2);
/* 002 [def:0001] [use:0001] */      case 0x4AD4: L_4ad4: //C4 11 90
/* 003 [def:0001] [use:0001] */          ZN=ram[0x0011];
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 005 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4AD4);
/* 007 [def:0001] [use:0001] */      case 0x4AD6: L_4ad6: //90 DE A0
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x4AD6);
/* 011 [def:0001] [use:0001] */              PC = 0x4ab6;
/*                           */              clockticks += 44;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4AD6);
/* 002 [def:0001] [use:0001] */      case 0x4AD8: L_4ad8: //A0 1A 94
/* 003 [def:0021] [use:0000] */          Y=0x1A;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4AD8);
/* 006 [def:0001] [use:0001] */      case 0x4ADA: L_4ada: //94 D1 A6
/* 007 [def:0001] [use:0011] */          temp=(0x00D1 + X)&0xFF;
/* 008 [def:0001] [use:0001] */          ram[temp] = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4ADA);
/* 010 [def:0001] [use:0001] */      case 0x4ADC: L_4adc: //A6 10 20
/* 011 [def:0001] [use:0001] */          X=ram[0x0010];
/* 012 [def:1801] [use:0010] */          ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4ADC);
/* 014 [def:0001] [use:0001] */      case 0x4ADE: L_4ade: //20 E7 69
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0xE0;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4ADE);
/* 018 [def:0001] [use:0001] */          PC = 0x69e7;
/*                           */          clockticks += 59; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4AE1: L_4ae1: //20 4D 4B
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xE3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4AE1);
/* 004 [def:0001] [use:0001] */          PC = 0x4b4d;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4AE4: L_4ae4: //A0 02 84
/* 001 [def:0021] [use:0000] */          Y=0x02;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4AE4);
/* 004 [def:0001] [use:0001] */      case 0x4AE6: L_4ae6: //84 DD 98
/* 005 [def:0001] [use:0020] */          ram[0x00DD] = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4AE6);
/* 007 [def:0001] [use:0001] */      case 0x4AE8: L_4ae8: //98 0A 0A
/* 008 [def:0001] [use:0001] */          A=Y;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4AE8);
/* 011 [def:0001] [use:0001] */      case 0x4AE9: L_4ae9: //0A 0A 09
/* 012 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 013 [def:0009] [use:0008] */          A = A << 1;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x4AE9);
/* 016 [def:0001] [use:0001] */      case 0x4AEA: L_4aea: //0A 09 42
/* 017 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 018 [def:0009] [use:0008] */          A = A << 1;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4AEA);
/* 021 [def:0001] [use:0001] */      case 0x4AEB: L_4aeb: //09 42 9D
/* 022 [def:0001] [use:0001] */          A |= 0x42;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x4AEB);
/* 025 [def:0001] [use:0001] */      case 0x4AED: L_4aed: //9D 00 02
/* 026 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x4AED);
/* 028 [def:0001] [use:0001] */      case 0x4AF0: L_4af0: //EE E7 02
/* 029 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 030 [def:0001] [use:0001] */          //trace_PC(0x4AF0);
/* 031 [def:0001] [use:0001] */      case 0x4AF3: L_4af3: //EE FF 02
/* 032 [def:1801] [use:0001] */          ZN=++ram[0x02FF];
/* 033 [def:0001] [use:0001] */          //trace_PC(0x4AF3);
/* 034 [def:0001] [use:0001] */      case 0x4AF6: L_4af6: //B9 47 4B
/* 035 [def:0009] [use:0021] */          A=ram[0x4B47 + Y /* can't wrap */];
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x4AF6);
/* 038 [def:0001] [use:0001] */      case 0x4AF9: L_4af9: //99 F8 02
/* 039 [def:0001] [use:0021] */          ram[(unsigned short)(0x02F8 + Y)] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x4AF9);
/* 041 [def:0001] [use:0001] */      case 0x4AFC: L_4afc: //B9 4A 4B
/* 042 [def:0009] [use:0021] */          A=ram[0x4B4A + Y /* can't wrap */];
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x4AFC);
/* 045 [def:0001] [use:0001] */      case 0x4AFF: L_4aff: //99 F1 02
/* 046 [def:0001] [use:0021] */          ram[(unsigned short)(0x02F1 + Y)] = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x4AFF);
/* 048 [def:0001] [use:0001] */      case 0x4B02: L_4b02: //B9 3B 4B
/* 049 [def:0009] [use:0021] */          A=ram[0x4B3B + Y /* can't wrap */];
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x4B02);
/* 052 [def:0001] [use:0001] */      case 0x4B05: L_4b05: //18 7D A5
/* 053 [def:2001] [use:0000] */          C = 0;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x4B05);
/* 055 [def:0001] [use:0001] */      case 0x4B06: L_4b06: //7D A5 02
/* 056 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02A5 + X)]);
/* 057 [def:0001] [use:0001] */          //trace_PC(0x4B06);
/* 058 [def:0001] [use:0001] */      case 0x4B09: L_4b09: //9D A5 02
/* 059 [def:0001] [use:0019] */          ram[0x02A5 + X /* can't wrap */] = A;
/* 060 [def:0001] [use:0001] */          //trace_PC(0x4B09);
/* 061 [def:0001] [use:0001] */      case 0x4B0C: L_4b0c: //B9 3E 4B
/* 062 [def:0009] [use:0021] */          A=ram[0x4B3E + Y /* can't wrap */];
/* 063 [def:1800] [use:0008] */  //      ZN = A;
/* 064 [def:0001] [use:0001] */          //trace_PC(0x4B0C);
/* 065 [def:0001] [use:0001] */      case 0x4B0F: L_4b0f: //7D 63 02
/* 066 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0263 + X)]);
/* 067 [def:0001] [use:0001] */          //trace_PC(0x4B0F);
/* 068 [def:0001] [use:0001] */      case 0x4B12: L_4b12: //9D 63 02
/* 069 [def:0001] [use:0019] */          ram[0x0263 + X /* can't wrap */] = A;
/* 070 [def:0001] [use:0001] */          //trace_PC(0x4B12);
/* 071 [def:0001] [use:0001] */      case 0x4B15: L_4b15: //B9 41 4B
/* 072 [def:0009] [use:0021] */          A=ram[0x4B41 + Y /* can't wrap */];
/* 073 [def:1800] [use:0008] */  //      ZN = A;
/* 074 [def:0001] [use:0001] */          //trace_PC(0x4B15);
/* 075 [def:0001] [use:0001] */      case 0x4B18: L_4b18: //18 7D C6
/* 076 [def:2001] [use:0000] */          C = 0;
/* 077 [def:0001] [use:0001] */          //trace_PC(0x4B18);
/* 078 [def:0001] [use:0001] */      case 0x4B19: L_4b19: //7D C6 02
/* 079 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02C6 + X)]);
/* 080 [def:0001] [use:0001] */          //trace_PC(0x4B19);
/* 081 [def:0001] [use:0001] */      case 0x4B1C: L_4b1c: //9D C6 02
/* 082 [def:0001] [use:0019] */          ram[0x02C6 + X /* can't wrap */] = A;
/* 083 [def:0001] [use:0001] */          //trace_PC(0x4B1C);
/* 084 [def:0001] [use:0001] */      case 0x4B1F: L_4b1f: //B9 44 4B
/* 085 [def:0009] [use:0021] */          A=ram[0x4B44 + Y /* can't wrap */];
/* 086 [def:1800] [use:0008] */  //      ZN = A;
/* 087 [def:0001] [use:0001] */          //trace_PC(0x4B1F);
/* 088 [def:0001] [use:0001] */      case 0x4B22: L_4b22: //7D 84 02
/* 089 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0284 + X)]);
/* 090 [def:0001] [use:0001] */          //trace_PC(0x4B22);
/* 091 [def:0001] [use:0001] */      case 0x4B25: L_4b25: //9D 84 02
/* 092 [def:0001] [use:0019] */          ram[0x0284 + X /* can't wrap */] = A;
/* 093 [def:0001] [use:0001] */          //trace_PC(0x4B25);
/* 094 [def:0001] [use:0001] */      case 0x4B28: L_4b28: //88 30 8B
/* 095 [def:0021] [use:0020] */          Y--;
/* 096 [def:1801] [use:0020] */          ZN = Y;
/* 097 [def:0001] [use:0001] */          //trace_PC(0x4B28);
/* 098 [def:0001] [use:0001] */      case 0x4B29: L_4b29: //30 8B 86
/* 099 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 100 [def:0001] [use:0001] */          {
/* 101 [def:0001] [use:0001] */              //trace_PC(0x4B29);
/* 102 [def:0001] [use:0001] */              PC = 0x4ab6;
/*                           */              clockticks += 110;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4B29);
/* 002 [def:0001] [use:0001] */      case 0x4B2B: L_4b2b: //86 10 20
/* 003 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4B2B);
/* 005 [def:0001] [use:0001] */      case 0x4B2D: L_4b2d: //20 52 6D
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x2F;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4B2D);
/* 009 [def:0001] [use:0001] */          PC = 0x6d52;
/*                           */          clockticks += 117; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4B30: L_4b30: //84 11 A4
/* 001 [def:0001] [use:0020] */          ram[0x0011] = Y;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4B30);
/* 003 [def:0001] [use:0001] */      case 0x4B32: L_4b32: //A4 10 20
/* 004 [def:0021] [use:0001] */          Y=ram[0x0010];
/* 005 [def:1801] [use:0020] */          ZN = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4B32);
/* 007 [def:0001] [use:0001] */      case 0x4B34: L_4b34: //20 EB 61
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x36;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4B34);
/* 011 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4B37: L_4b37: //A4 11 10
/* 001 [def:0021] [use:0001] */          Y=ram[0x0011];
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4B37);
/* 004 [def:0001] [use:0001] */      case 0x4B39: L_4b39: //10 AD 00
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x4B39);
/* 008 [def:0001] [use:0001] */              PC = 0x4ae8;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4B39);
/* 002 [def:0001] [use:0001] */      case 0x4B4D: L_4b4d: //20 53 4B
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x4F;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4B4D);
/* 006 [def:0001] [use:0001] */          PC = 0x4b53;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4B50: L_4b50: //9D 21 02
/* 001 [def:0001] [use:0019] */          ram[0x0221 + X /* can't wrap */] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4B50);
/* 003 [def:0001] [use:0001] */      case 0x4B53: L_4b53: //A0 06 AD
/* 004 [def:0021] [use:0000] */          Y=0x06;
/* 005 [def:1800] [use:0020] */  //      ZN = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4B53);
/* 007 [def:0001] [use:0001] */      case 0x4B55: L_4b55: //AD 0A 2C
/* 008 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4B55);
/* 011 [def:0001] [use:0001] */      case 0x4B58: L_4b58: //10 02 A0
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4B58);
/* 015 [def:0001] [use:0001] */              PC = 0x4b5c;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4B58);
/* 002 [def:0001] [use:0001] */      case 0x4B5A: L_4b5a: //A0 FA 98
/* 003 [def:0021] [use:0000] */          Y=0xFA;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4B5A);
/* 006 [def:0001] [use:0001] */      case 0x4B5C: L_4b5c: //98 9D 42
/* 007 [def:0001] [use:0001] */          A=Y;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4B5C);
/* 010 [def:0001] [use:0001] */      case 0x4B5D: L_4b5d: //9D 42 02
/* 011 [def:0001] [use:0019] */          ram[0x0242 + X /* can't wrap */] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4B5D);
/* 013 [def:0001] [use:0001] */      case 0x4B60: L_4b60: //60 00 03
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4B60);
/* 015 [def:0001] [use:0001] */          PC=stack[++S];
/* 016 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 017 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 30; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BA2: L_4ba2: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4BA2);
/* 004 [def:0001] [use:0001] */      case 0x4BA4: L_4ba4: //29 03 AA
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4BA4);
/* 008 [def:0001] [use:0001] */      case 0x4BA6: L_4ba6: //AA 18 69
/* 009 [def:0011] [use:0008] */          X=A;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4BA6);
/* 012 [def:0001] [use:0001] */      case 0x4BA7: L_4ba7: //18 69 FE
/* 013 [def:2001] [use:0000] */          C = 0;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4BA7);
/* 015 [def:0001] [use:0001] */      case 0x4BA8: L_4ba8: //69 FE 75
/* 016 [def:b801] [use:6001] */          ADC(0xFE);
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4BA8);
/* 018 [def:0001] [use:0001] */      case 0x4BAA: L_4baa: //75 86 95
/* 019 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x86 + X)]); /* zero page */
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4BAA);
/* 021 [def:0001] [use:0001] */      case 0x4BAC: L_4bac: //95 86 29
/* 022 [def:0001] [use:0019] */          ram[(unsigned char)(0x86 + X)] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4BAC);
/* 024 [def:0001] [use:0001] */      case 0x4BAE: L_4bae: //29 F0 18
/* 025 [def:0009] [use:0008] */          A &= 0xF0;
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x4BAE);
/* 028 [def:0001] [use:0001] */      case 0x4BB0: L_4bb0: //18 75 86
/* 029 [def:2001] [use:0000] */          C = 0;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x4BB0);
/* 031 [def:0001] [use:0001] */      case 0x4BB1: L_4bb1: //75 86 0A
/* 032 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x86 + X)]); /* zero page */
/* 033 [def:0001] [use:0001] */          //trace_PC(0x4BB1);
/* 034 [def:0001] [use:0001] */      case 0x4BB3: L_4bb3: //0A 20 C6
/* 035 [def:2001] [use:0008] */          C = A & 0x80;
/* 036 [def:0009] [use:0008] */          A = A << 1;
/* 037 [def:1801] [use:0008] */          ZN = A;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x4BB3);
/* 039 [def:0001] [use:0001] */      case 0x4BB4: L_4bb4: //20 C6 6E
/* 040 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 041 [def:0001] [use:0001] */          stack[S--] = 0xB6;
/* 042 [def:0001] [use:0001] */          //trace_PC(0x4BB4);
/* 043 [def:0001] [use:0001] */          PC = 0x6ec6;
/*                           */          clockticks += 38; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BB7: L_4bb7: //B9 02 50
/* 001 [def:0009] [use:0021] */          A=ram[0x5002 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4BB7);
/* 004 [def:0001] [use:0001] */      case 0x4BBA: L_4bba: //85 10 B9
/* 005 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4BBA);
/* 007 [def:0001] [use:0001] */      case 0x4BBC: L_4bbc: //B9 03 50
/* 008 [def:0009] [use:0021] */          A=ram[0x5003 + Y /* can't wrap */];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4BBC);
/* 011 [def:0001] [use:0001] */      case 0x4BBF: L_4bbf: //85 11 8A
/* 012 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4BBF);
/* 014 [def:0001] [use:0001] */      case 0x4BC1: L_4bc1: //8A 0A AA
/* 015 [def:0001] [use:0001] */          A=X;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4BC1);
/* 018 [def:0001] [use:0001] */      case 0x4BC2: L_4bc2: //0A AA 0A
/* 019 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 020 [def:0009] [use:0008] */          A = A << 1;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x4BC2);
/* 023 [def:0001] [use:0001] */      case 0x4BC3: L_4bc3: //AA 0A 29
/* 024 [def:0011] [use:0008] */          X=A;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x4BC3);
/* 027 [def:0001] [use:0001] */      case 0x4BC4: L_4bc4: //0A 29 04
/* 028 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 029 [def:0009] [use:0008] */          A = A << 1;
/* 030 [def:1800] [use:0008] */  //      ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x4BC4);
/* 032 [def:0001] [use:0001] */      case 0x4BC5: L_4bc5: //29 04 45
/* 033 [def:0009] [use:0008] */          A &= 0x04;
/* 034 [def:1800] [use:0008] */  //      ZN = A;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x4BC5);
/* 036 [def:0001] [use:0001] */      case 0x4BC7: L_4bc7: //45 09 85
/* 037 [def:0001] [use:0001] */          A^=ram[0x0009];
/* 038 [def:1800] [use:0008] */  //      ZN = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x4BC7);
/* 040 [def:0001] [use:0001] */      case 0x4BC9: L_4bc9: //85 09 BD
/* 041 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 042 [def:0001] [use:0001] */          //trace_PC(0x4BC9);
/* 043 [def:0001] [use:0001] */      case 0x4BCB: L_4bcb: //BD 9D 77
/* 044 [def:0009] [use:0011] */          A=ram[0x779D + X /* can't wrap */];
/* 045 [def:1800] [use:0008] */  //      ZN = A;
/* 046 [def:0001] [use:0001] */          //trace_PC(0x4BCB);
/* 047 [def:0001] [use:0001] */      case 0x4BCE: L_4bce: //0A 85 03
/* 048 [def:2001] [use:0008] */          C = A & 0x80;
/* 049 [def:0009] [use:0008] */          A = A << 1;
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x4BCE);
/* 052 [def:0001] [use:0001] */      case 0x4BCF: L_4bcf: //85 03 BD
/* 053 [def:0001] [use:0008] */          ram[0x0003] = A;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x4BCF);
/* 055 [def:0001] [use:0001] */      case 0x4BD1: L_4bd1: //BD 9E 77
/* 056 [def:0009] [use:0011] */          A=ram[0x779E + X /* can't wrap */];
/* 057 [def:1800] [use:0008] */  //      ZN = A;
/* 058 [def:0001] [use:0001] */          //trace_PC(0x4BD1);
/* 059 [def:0001] [use:0001] */      case 0x4BD4: L_4bd4: //2A 49 C0
/* 060 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 061 [def:2001] [use:0008] */          C = A & 0x80;
/* 062 [def:0009] [use:0008] */          A = A << 1;
/* 063 [def:0009] [use:10008] */          A |= saveflags;
/* 064 [def:1800] [use:0008] */  //      ZN = A;
/* 065 [def:0001] [use:0001] */          //trace_PC(0x4BD4);
/* 066 [def:0001] [use:0001] */      case 0x4BD5: L_4bd5: //49 C0 85
/* 067 [def:0009] [use:0008] */          A ^= 0xC0;
/* 068 [def:1800] [use:0008] */  //      ZN = A;
/* 069 [def:0001] [use:0001] */          //trace_PC(0x4BD5);
/* 070 [def:0001] [use:0001] */      case 0x4BD7: L_4bd7: //85 04 A2
/* 071 [def:0001] [use:0008] */          ram[0x0004] = A;
/* 072 [def:0001] [use:0001] */          //trace_PC(0x4BD7);
/* 073 [def:0001] [use:0001] */      case 0x4BD9: L_4bd9: //A2 0C 20
/* 074 [def:0001] [use:0001] */          X=0x0C;
/* 075 [def:1801] [use:0010] */          ZN = X;
/* 076 [def:0001] [use:0001] */          //trace_PC(0x4BD9);
/* 077 [def:0001] [use:0001] */      case 0x4BDB: L_4bdb: //20 21 62
/* 078 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 079 [def:0001] [use:0001] */          stack[S--] = 0xDD;
/* 080 [def:0001] [use:0001] */          //trace_PC(0x4BDB);
/* 081 [def:0001] [use:0001] */          PC = 0x6221;
/*                           */          clockticks += 56; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BDE: L_4bde: //4C D6 79
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4BDE);
/* 002 [def:0001] [use:0001] */          PC = 0x79d6;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BE1: L_4be1: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4BE1);
/* 004 [def:0001] [use:0001] */      case 0x4BE3: L_4be3: //F0 0E A5
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x4BE3);
/* 008 [def:0001] [use:0001] */              PC = 0x4bf3;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4BE3);
/* 002 [def:0001] [use:0001] */      case 0x4BE5: L_4be5: //A5 74 D0
/* 003 [def:0009] [use:0001] */          A=ram[0x0074];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4BE5);
/* 006 [def:0001] [use:0001] */      case 0x4BE7: L_4be7: //D0 03 4C
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x4BE7);
/* 010 [def:0001] [use:0001] */              PC = 0x4bec;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4BE7);
/* 002 [def:0001] [use:0001] */      case 0x4BE9: L_4be9: //4C F6 4C
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4BE9);
/* 004 [def:0001] [use:0001] */          PC = 0x4cf6;
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BEC: L_4bec: //C6 74 20
/* 001 [def:0001] [use:0001] */          ZN=ram[0x0074]-1;
/* 002 [def:0001] [use:0001] */          ram[0x0074] = ZN;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4BEC);
/* 004 [def:0001] [use:0001] */      case 0x4BEE: L_4bee: //20 EB 60
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x4B;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xF0;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4BEE);
/* 008 [def:0001] [use:0001] */          PC = 0x60eb;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BF1: L_4bf1: //18 60 85
/* 001 [def:2001] [use:0000] */          C = 0;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4BF1);
/* 003 [def:0001] [use:0001] */      case 0x4BF2: L_4bf2: //60 85 13
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4BF2);
/* 005 [def:0001] [use:0001] */          PC=stack[++S];
/* 006 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 007 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4BF3: L_4bf3: //85 13 A5
/* 001 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4BF3);
/* 003 [def:0001] [use:0001] */      case 0x4BF5: L_4bf5: //A5 8D 29
/* 004 [def:0009] [use:0001] */          A=ram[0x008D];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4BF5);
/* 007 [def:0001] [use:0001] */      case 0x4BF7: L_4bf7: //29 03 D0
/* 008 [def:0009] [use:0008] */          A &= 0x03;
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4BF7);
/* 011 [def:0001] [use:0001] */      case 0x4BF9: L_4bf9: //D0 06 A9
/* 012 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4BF9);
/* 015 [def:0001] [use:0001] */              PC = 0x4c01;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4BF9);
/* 002 [def:0001] [use:0001] */      case 0x4BFB: L_4bfb: //A9 02 85
/* 003 [def:0009] [use:0000] */          A=0x02;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4BFB);
/* 006 [def:0001] [use:0001] */      case 0x4BFD: L_4bfd: //85 8C D0
/* 007 [def:0001] [use:0008] */          ram[0x008C] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4BFD);
/* 009 [def:0001] [use:0001] */      case 0x4BFF: L_4bff: //D0 56 18
/* 010 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x4BFF);
/* 013 [def:0001] [use:0001] */              PC = 0x4c57;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4BFF);
/* 002 [def:0001] [use:0001] */      case 0x4C01: L_4c01: //18 69 07
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4C01);
/* 005 [def:0001] [use:0001] */      case 0x4C57: L_4c57: //A0 06 A6
/* 006 [def:0021] [use:0000] */          Y=0x06;
/* 007 [def:1800] [use:0020] */  //      ZN = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4C57);
/* 009 [def:0001] [use:0001] */      case 0x4C59: L_4c59: //A6 8C D0
/* 010 [def:0001] [use:0001] */          X=ram[0x008C];
/* 011 [def:1801] [use:0010] */          ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4C59);
/* 013 [def:0001] [use:0001] */      case 0x4C5B: L_4c5b: //D0 02 86
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x4C5B);
/* 017 [def:0001] [use:0001] */              PC = 0x4c5f;
/*                           */              clockticks += 28;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C5B);
/* 002 [def:0001] [use:0001] */      case 0x4C5F: L_4c5f: //AD 01 28
/* 003 [def:0009] [use:0001] */          A=ram[0x2801];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4C5F);
/* 006 [def:0001] [use:0001] */      case 0x4C62: L_4c62: //4A 90 10
/* 007 [def:2001] [use:0008] */          C = A & 0x01;
/* 008 [def:0009] [use:0008] */          A = A >> 1;
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4C62);
/* 011 [def:0001] [use:0001] */      case 0x4C63: L_4c63: //90 10 24
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4C63);
/* 015 [def:0001] [use:0001] */              PC = 0x4c75;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C63);
/* 002 [def:0001] [use:0001] */      case 0x4C75: L_4c75: //A9 FF 85
/* 003 [def:0009] [use:0000] */          A=0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4C75);
/* 006 [def:0001] [use:0001] */      case 0x4C77: L_4c77: //85 8A C0
/* 007 [def:0001] [use:0008] */          ram[0x008A] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4C77);
/* 009 [def:0001] [use:0001] */      case 0x4C79: L_4c79: //C0 0C D0
/* 010 [def:0101] [use:0001] */          ZN=0x0C;
/* 011 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 012 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4C79);
/* 014 [def:0001] [use:0001] */      case 0x4C7B: L_4c7b: //D0 09 20
/* 015 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x4C7B);
/* 018 [def:0001] [use:0001] */              PC = 0x4c86;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C7B);
/* 002 [def:0001] [use:0001] */      case 0x4C80: L_4c80: //18 A9 00
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4C80);
/* 005 [def:0001] [use:0001] */      case 0x4C86: L_4c86: //8A F0 F7
/* 006 [def:0001] [use:0001] */          A=X;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4C86);
/* 009 [def:0001] [use:0001] */      case 0x4C87: L_4c87: //F0 F7 20
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x4C87);
/* 013 [def:0001] [use:0001] */              PC = 0x4c80;
/*                           */              clockticks += 52;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C87);
/* 002 [def:0001] [use:0001] */      case 0x4C89: L_4c89: //20 DB 60
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x8B;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4C89);
/* 006 [def:0001] [use:0001] */          PC = 0x60db;
/*                           */          clockticks += 57; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4C8C: L_4c8c: //A4 8C A2
/* 001 [def:0021] [use:0001] */          Y=ram[0x008C];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4C8C);
/* 004 [def:0001] [use:0001] */      case 0x4C8E: L_4c8e: //A2 01 AD
/* 005 [def:0001] [use:0001] */          X=0x01;
/* 006 [def:1800] [use:0010] */  //      ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4C8E);
/* 008 [def:0001] [use:0001] */      case 0x4C90: L_4c90: //AD 03 24
/* 009 [def:0001] [use:0001] */          if(ram[0x2403]==0xFF) {
/* 010 [def:0001] [use:0001] */             ram[0x2403]=0; /* NO LONGER DONE IN WRITEMEM() */
/* 011 [def:0001] [use:0001] */             A=0xff;
/* 012 [def:0009] [use:0001] */          }
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4C90);
/* 015 [def:0001] [use:0001] */      case 0x4C93: L_4c93: //30 20 C0
/* 016 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x4C93);
/* 019 [def:0001] [use:0001] */              PC = 0x4cb5;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C93);
/* 002 [def:0001] [use:0001] */      case 0x4C95: L_4c95: //C0 02 90
/* 003 [def:0101] [use:0001] */          ZN=0x02;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4C95);
/* 007 [def:0001] [use:0001] */      case 0x4C97: L_4c97: //90 49 AD
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x4C97);
/* 011 [def:0001] [use:0001] */              PC = 0x4ce2;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C97);
/* 002 [def:0001] [use:0001] */      case 0x4C99: L_4c99: //AD 04 24
/* 003 [def:0009] [use:0001] */          A=ram[0x2404];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4C99);
/* 006 [def:0001] [use:0001] */      case 0x4C9C: L_4c9c: //10 44 8D
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x4C9C);
/* 010 [def:0001] [use:0001] */              PC = 0x4ce2;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4C9C);
/* 002 [def:0001] [use:0001] */      case 0x4CB5: L_4cb5: //86 22 C6
/* 003 [def:0001] [use:0001] */          ram[0x0022] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4CB5);
/* 005 [def:0001] [use:0001] */      case 0x4CB7: L_4cb7: //C6 8C 8E
/* 006 [def:0001] [use:0001] */          ZN=ram[0x008C]-1;
/* 007 [def:0001] [use:0001] */          ram[0x008C] = ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4CB7);
/* 009 [def:0001] [use:0001] */      case 0x4CB9: L_4cb9: //8E 04 3C
/* 010 [def:0001] [use:0001] */          ram[0x3C04] = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4CB9);
/* 012 [def:0001] [use:0001] */      case 0x4CBC: L_4cbc: //86 85 20
/* 013 [def:0001] [use:0001] */          ram[0x0085] = X;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4CBC);
/* 015 [def:0001] [use:0001] */      case 0x4CBE: L_4cbe: //20 D0 60
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 017 [def:0001] [use:0001] */          stack[S--] = 0xC0;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x4CBE);
/* 019 [def:0001] [use:0001] */          PC = 0x60d0;
/*                           */          clockticks += 42; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4CC1: L_4cc1: //20 E3 7B
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xC3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4CC1);
/* 004 [def:0001] [use:0001] */          PC = 0x7be3;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4CC4: L_4cc4: //20 1B 6A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xC6;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4CC4);
/* 004 [def:0001] [use:0001] */          PC = 0x6a1b;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4CC7: L_4cc7: //A9 80 85
/* 001 [def:0009] [use:0000] */          A=0x80;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4CC7);
/* 004 [def:0001] [use:0001] */      case 0x4CC9: L_4cc9: //85 74 0A
/* 005 [def:0001] [use:0008] */          ram[0x0074] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4CC9);
/* 007 [def:0001] [use:0001] */      case 0x4CCB: L_4ccb: //0A 85 1E
/* 008 [def:2001] [use:0008] */          C = A & 0x80;
/* 009 [def:0009] [use:0008] */          A = A << 1;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4CCB);
/* 012 [def:0001] [use:0001] */      case 0x4CCC: L_4ccc: //85 1E 85
/* 013 [def:0001] [use:0008] */          ram[0x001E] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x4CCC);
/* 015 [def:0001] [use:0001] */      case 0x4CCE: L_4cce: //85 1F 85
/* 016 [def:0001] [use:0008] */          ram[0x001F] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4CCE);
/* 018 [def:0001] [use:0001] */      case 0x4CD0: L_4cd0: //85 20 85
/* 019 [def:0001] [use:0008] */          ram[0x0020] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x4CD0);
/* 021 [def:0001] [use:0001] */      case 0x4CD2: L_4cd2: //85 9A 85
/* 022 [def:0001] [use:0008] */          ram[0x009A] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x4CD2);
/* 024 [def:0001] [use:0001] */      case 0x4CD4: L_4cd4: //85 99 A5
/* 025 [def:0001] [use:0008] */          ram[0x0099] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x4CD4);
/* 027 [def:0001] [use:0001] */      case 0x4CD6: L_4cd6: //A5 6E 85
/* 028 [def:0009] [use:0001] */          A=ram[0x006E];
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x4CD6);
/* 031 [def:0001] [use:0001] */      case 0x4CD8: L_4cd8: //85 6F A9
/* 032 [def:0001] [use:0008] */          ram[0x006F] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x4CD8);
/* 034 [def:0001] [use:0001] */      case 0x4CDA: L_4cda: //A9 04 85
/* 035 [def:0009] [use:0000] */          A=0x04;
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x4CDA);
/* 038 [def:0001] [use:0001] */      case 0x4CDC: L_4cdc: //85 84 8D
/* 039 [def:0001] [use:0008] */          ram[0x0084] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x4CDC);
/* 041 [def:0001] [use:0001] */      case 0x4CDE: L_4cde: //8D 00 3E
/* 042 [def:0001] [use:0008] */          ram[0x3E00] = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x4CDE);
/* 044 [def:0001] [use:0001] */      case 0x4CE1: L_4ce1: //60 A5 76
/* 045 [def:0001] [use:0001] */          //trace_PC(0x4CE1);
/* 046 [def:0001] [use:0001] */          PC=stack[++S];
/* 047 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 048 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 37; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4CE2: L_4ce2: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4CE2);
/* 004 [def:0001] [use:0001] */      case 0x4CE4: L_4ce4: //29 0F D0
/* 005 [def:0009] [use:0008] */          A &= 0x0F;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4CE4);
/* 008 [def:0001] [use:0001] */      case 0x4CE6: L_4ce6: //D0 0C A9
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x4CE6);
/* 012 [def:0001] [use:0001] */              PC = 0x4cf4;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4CE6);
/* 002 [def:0001] [use:0001] */      case 0x4CE8: L_4ce8: //A9 01 C5
/* 003 [def:0009] [use:0000] */          A=0x01;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4CE8);
/* 006 [def:0001] [use:0001] */      case 0x4CEA: L_4cea: //C5 8C F0
/* 007 [def:0001] [use:0001] */          ZN=ram[0x008C];
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4CEA);
/* 011 [def:0001] [use:0001] */      case 0x4CEC: L_4cec: //F0 02 A9
/* 012 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4CEC);
/* 015 [def:0001] [use:0001] */              PC = 0x4cf0;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4CEC);
/* 002 [def:0001] [use:0001] */      case 0x4CEE: L_4cee: //A9 03 45
/* 003 [def:0009] [use:0000] */          A=0x03;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4CEE);
/* 006 [def:0001] [use:0001] */      case 0x4CF0: L_4cf0: //45 85 85
/* 007 [def:0001] [use:0001] */          A^=ram[0x0085];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4CF0);
/* 010 [def:0001] [use:0001] */      case 0x4CF2: L_4cf2: //85 85 18
/* 011 [def:0001] [use:0008] */          ram[0x0085] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4CF2);
/* 013 [def:0001] [use:0001] */      case 0x4CF4: L_4cf4: //18 60 A5
/* 014 [def:2001] [use:0000] */          C = 0;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x4CF4);
/* 016 [def:0001] [use:0001] */      case 0x4CF5: L_4cf5: //60 A5 76
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4CF5);
/* 018 [def:0001] [use:0001] */          PC=stack[++S];
/* 019 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 020 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 32; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4CF6: L_4cf6: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4CF6);
/* 004 [def:0001] [use:0001] */      case 0x4CF8: L_4cf8: //29 3F D0
/* 005 [def:0009] [use:0008] */          A &= 0x3F;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4CF8);
/* 008 [def:0001] [use:0001] */      case 0x4CFA: L_4cfa: //D0 0A AD
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x4CFA);
/* 012 [def:0001] [use:0001] */              PC = 0x4d06;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4CFA);
/* 002 [def:0001] [use:0001] */      case 0x4CFC: L_4cfc: //AD ED 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02ED];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4CFC);
/* 006 [def:0001] [use:0001] */      case 0x4CFF: L_4cff: //C9 08 F0
/* 007 [def:0101] [use:0000] */          ZN=0x08;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4CFF);
/* 011 [def:0001] [use:0001] */      case 0x4D01: L_4d01: //F0 03 CE
/* 012 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4D01);
/* 015 [def:0001] [use:0001] */              PC = 0x4d06;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D01);
/* 002 [def:0001] [use:0001] */      case 0x4D03: L_4d03: //CE ED 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02ED];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4D03);
/* 005 [def:0001] [use:0001] */      case 0x4D06: L_4d06: //A6 1E B5
/* 006 [def:0001] [use:0001] */          X=ram[0x001E];
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4D06);
/* 009 [def:0001] [use:0001] */      case 0x4D08: L_4d08: //B5 6F D0
/* 010 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x6f + X)];
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x4D08);
/* 013 [def:0001] [use:0001] */      case 0x4D0A: L_4d0a: //D0 1C AD
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x4D0A);
/* 017 [def:0001] [use:0001] */              PC = 0x4d28;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D0A);
/* 002 [def:0001] [use:0001] */      case 0x4D0C: L_4d0c: //AD 1D 02
/* 003 [def:0009] [use:0001] */          A=ram[0x021D];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D0C);
/* 006 [def:0001] [use:0001] */      case 0x4D0F: L_4d0f: //0D 1E 02
/* 007 [def:0001] [use:0001] */          A|=ram[0x021E];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4D0F);
/* 010 [def:0001] [use:0001] */      case 0x4D12: L_4d12: //0D 1F 02
/* 011 [def:0001] [use:0001] */          A|=ram[0x021F];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4D12);
/* 014 [def:0001] [use:0001] */      case 0x4D15: L_4d15: //0D 20 02
/* 015 [def:0001] [use:0001] */          A|=ram[0x0220];
/* 016 [def:1801] [use:0008] */          ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x4D15);
/* 018 [def:0001] [use:0001] */      case 0x4D18: L_4d18: //D0 0E A0
/* 019 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 020 [def:0001] [use:0001] */          {
/* 021 [def:0001] [use:0001] */              //trace_PC(0x4D18);
/* 022 [def:0001] [use:0001] */              PC = 0x4d28;
/*                           */              clockticks += 51;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D18);
/* 002 [def:0001] [use:0001] */      case 0x4D1A: L_4d1a: //A0 07 20
/* 003 [def:0021] [use:0000] */          Y=0x07;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D1A);
/* 006 [def:0001] [use:0001] */      case 0x4D1C: L_4d1c: //20 59 71
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x4D;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x1E;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4D1C);
/* 010 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 59; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4D1F: L_4d1f: //A5 22 C9
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4D1F);
/* 004 [def:0001] [use:0001] */      case 0x4D21: L_4d21: //C9 02 90
/* 005 [def:0101] [use:0000] */          ZN=0x02;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x4D21);
/* 009 [def:0001] [use:0001] */      case 0x4D23: L_4d23: //90 03 20
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x4D23);
/* 013 [def:0001] [use:0001] */              PC = 0x4d28;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D23);
/* 002 [def:0001] [use:0001] */      case 0x4D28: L_4d28: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D28);
/* 006 [def:0001] [use:0001] */      case 0x4D2B: L_4d2b: //D0 37 AD
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x4D2B);
/* 010 [def:0001] [use:0001] */              PC = 0x4d64;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D2B);
/* 002 [def:0001] [use:0001] */      case 0x4D2D: L_4d2d: //AD EB 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EB];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D2D);
/* 006 [def:0001] [use:0001] */      case 0x4D30: L_4d30: //C9 80 D0
/* 007 [def:0101] [use:0000] */          ZN=0x80;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x4D30);
/* 011 [def:0001] [use:0001] */      case 0x4D32: L_4d32: //D0 30 A9
/* 012 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x4D32);
/* 015 [def:0001] [use:0001] */              PC = 0x4d64;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D32);
/* 002 [def:0001] [use:0001] */      case 0x4D34: L_4d34: //A9 10 20
/* 003 [def:0009] [use:0000] */          A=0x10;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D34);
/* 006 [def:0001] [use:0001] */      case 0x4D36: L_4d36: //20 00 63
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x4D;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x38;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4D36);
/* 010 [def:0001] [use:0001] */          PC = 0x6300;
/*                           */          clockticks += 32; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4D39: L_4d39: //A6 22 A5
/* 001 [def:0001] [use:0001] */          X=ram[0x0022];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4D39);
/* 004 [def:0001] [use:0001] */      case 0x4D3B: L_4d3b: //A5 6F 05
/* 005 [def:0009] [use:0001] */          A=ram[0x006F];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x4D3B);
/* 008 [def:0001] [use:0001] */      case 0x4D3D: L_4d3d: //05 70 F0
/* 009 [def:0009] [use:0009] */          A|=ram[0x0070];
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x4D3D);
/* 012 [def:0001] [use:0001] */      case 0x4D3F: L_4d3f: //F0 25 20
/* 013 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x4D3F);
/* 016 [def:0001] [use:0001] */              PC = 0x4d66;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D3F);
/* 002 [def:0001] [use:0001] */      case 0x4D41: L_4d41: //20 EB 67
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x4D;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x43;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x4D41);
/* 006 [def:0001] [use:0001] */          PC = 0x67eb;
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4D44: L_4d44: //CA F0 1D
/* 001 [def:0011] [use:0010] */          X--;
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x4D44);
/* 004 [def:0001] [use:0001] */      case 0x4D45: L_4d45: //F0 1D A9
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x4D45);
/* 008 [def:0001] [use:0001] */              PC = 0x4d64;
/*                           */              clockticks += 5;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D45);
/* 002 [def:0001] [use:0001] */      case 0x4D64: L_4d64: //18 60 86
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x4D64);
/* 005 [def:0001] [use:0001] */      case 0x4D65: L_4d65: //60 86 21
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4D65);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x4D66: L_4d66: //86 21 A9
/* 001 [def:0001] [use:0001] */          ram[0x0021] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x4D66);
/* 003 [def:0001] [use:0001] */      case 0x4D68: L_4d68: //A9 FF 85
/* 004 [def:0009] [use:0000] */          A=0xFF;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x4D68);
/* 007 [def:0001] [use:0001] */      case 0x4D6A: L_4d6a: //85 22 A9
/* 008 [def:0001] [use:0008] */          ram[0x0022] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x4D6A);
/* 010 [def:0001] [use:0001] */      case 0x4D6C: L_4d6c: //A9 03 85
/* 011 [def:0009] [use:0000] */          A=0x03;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x4D6C);
/* 014 [def:0001] [use:0001] */      case 0x4D6E: L_4d6e: //85 85 8D
/* 015 [def:0001] [use:0008] */          ram[0x0085] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x4D6E);
/* 017 [def:0001] [use:0001] */      case 0x4D70: L_4d70: //8D 04 3C
/* 018 [def:0001] [use:0008] */          ram[0x3C04] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x4D70);
/* 020 [def:0001] [use:0001] */      case 0x4D73: L_4d73: //D0 EF 10
/* 021 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x4D73);
/* 024 [def:0001] [use:0001] */              PC = 0x4d64;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x4D73);
/* 002 [def:0001] [use:0001] */      case 0x6000: L_6000: //20 E3 7B
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x02;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6000);
/* 006 [def:0001] [use:0001] */          PC = 0x7be3;
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6003: L_6003: //A5 CD D0
/* 001 [def:0009] [use:0001] */          A=ram[0x00CD];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6003);
/* 004 [def:0001] [use:0001] */      case 0x6005: L_6005: //D0 0A 85
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6005);
/* 008 [def:0001] [use:0001] */              PC = 0x6011;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6005);
/* 002 [def:0001] [use:0001] */      case 0x6007: L_6007: //85 CC 85
/* 003 [def:0001] [use:0008] */          ram[0x00CC] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6007);
/* 005 [def:0001] [use:0001] */      case 0x6009: L_6009: //85 CB 85
/* 006 [def:0001] [use:0008] */          ram[0x00CB] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6009);
/* 008 [def:0001] [use:0001] */      case 0x600B: L_600b: //85 CE A9
/* 009 [def:0001] [use:0008] */          ram[0x00CE] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x600B);
/* 011 [def:0001] [use:0001] */      case 0x600D: L_600d: //A9 20 85
/* 012 [def:0009] [use:0000] */          A=0x20;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x600D);
/* 015 [def:0001] [use:0001] */      case 0x600F: L_600f: //85 CD 20
/* 016 [def:0001] [use:0008] */          ram[0x00CD] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x600F);
/* 018 [def:0001] [use:0001] */      case 0x6011: L_6011: //20 59 69
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 020 [def:0001] [use:0001] */          stack[S--] = 0x13;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6011);
/* 022 [def:0001] [use:0001] */          PC = 0x6959;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6014: L_6014: //2C 02 20
/* 001 [def:1101] [use:0001] */          ZN=ram[0x2002];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6014);
/* 005 [def:0001] [use:0001] */      case 0x6017: L_6017: //30 FB 20
/* 006 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6017);
/* 009 [def:0001] [use:0001] */              PC = 0x6014;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6017);
/* 002 [def:0001] [use:0001] */      case 0x6019: L_6019: //20 A2 4B
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x1B;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6019);
/* 006 [def:0001] [use:0001] */          PC = 0x4ba2;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x601C: L_601c: //46 75 90
/* 001 [def:0101] [use:0001] */          ZN=ram[0x0075];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 003 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 004 [def:0001] [use:0100] */          ram[0x0075] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x601C);
/* 006 [def:0001] [use:0001] */      case 0x601E: L_601e: //90 FC A5
/* 007 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x601E);
/* 010 [def:0001] [use:0001] */              PC = 0x601c;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x601E);
/* 002 [def:0001] [use:0001] */      case 0x6020: L_6020: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6020);
/* 006 [def:0001] [use:0001] */      case 0x6022: L_6022: //29 01 0A
/* 007 [def:0009] [use:0008] */          A &= 0x01;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6022);
/* 010 [def:0001] [use:0001] */      case 0x6024: L_6024: //0A AA 49
/* 011 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 012 [def:0009] [use:0008] */          A = A << 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6024);
/* 015 [def:0001] [use:0001] */      case 0x6025: L_6025: //AA 49 02
/* 016 [def:0011] [use:0008] */          X=A;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6025);
/* 019 [def:0001] [use:0001] */      case 0x6026: L_6026: //49 02 A8
/* 020 [def:0009] [use:0008] */          A ^= 0x02;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6026);
/* 023 [def:0001] [use:0001] */      case 0x6028: L_6028: //A8 BD 99
/* 024 [def:0021] [use:0008] */          Y=A;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6028);
/* 027 [def:0001] [use:0001] */      case 0x6029: L_6029: //BD 99 77
/* 028 [def:0009] [use:0011] */          A=ram[0x7799 + X /* can't wrap */];
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6029);
/* 031 [def:0001] [use:0001] */      case 0x602C: L_602c: //8D 00 40
/* 032 [def:0001] [use:0008] */          ram[0x4000] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x602C);
/* 034 [def:0001] [use:0001] */      case 0x602F: L_602f: //BD 9A 77
/* 035 [def:0009] [use:0011] */          A=ram[0x779A + X /* can't wrap */];
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x602F);
/* 038 [def:0001] [use:0001] */      case 0x6032: L_6032: //8D 01 40
/* 039 [def:0001] [use:0008] */          ram[0x4001] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6032);
/* 041 [def:0001] [use:0001] */      case 0x6035: L_6035: //B9 99 77
/* 042 [def:0009] [use:0021] */          A=ram[0x7799 + Y /* can't wrap */];
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x6035);
/* 045 [def:0001] [use:0001] */      case 0x6038: L_6038: //0A 85 03
/* 046 [def:2001] [use:0008] */          C = A & 0x80;
/* 047 [def:0009] [use:0008] */          A = A << 1;
/* 048 [def:1800] [use:0008] */  //      ZN = A;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x6038);
/* 050 [def:0001] [use:0001] */      case 0x6039: L_6039: //85 03 B9
/* 051 [def:0001] [use:0008] */          ram[0x0003] = A;
/* 052 [def:0001] [use:0001] */          //trace_PC(0x6039);
/* 053 [def:0001] [use:0001] */      case 0x603B: L_603b: //B9 9A 77
/* 054 [def:0009] [use:0021] */          A=ram[0x779A + Y /* can't wrap */];
/* 055 [def:1800] [use:0008] */  //      ZN = A;
/* 056 [def:0001] [use:0001] */          //trace_PC(0x603B);
/* 057 [def:0001] [use:0001] */      case 0x603E: L_603e: //2A 29 1F
/* 058 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 059 [def:2001] [use:0008] */          C = A & 0x80;
/* 060 [def:0009] [use:0008] */          A = A << 1;
/* 061 [def:0009] [use:10008] */          A |= saveflags;
/* 062 [def:1800] [use:0008] */  //      ZN = A;
/* 063 [def:0001] [use:0001] */          //trace_PC(0x603E);
/* 064 [def:0001] [use:0001] */      case 0x603F: L_603f: //29 1F 09
/* 065 [def:0009] [use:0008] */          A &= 0x1F;
/* 066 [def:1800] [use:0008] */  //      ZN = A;
/* 067 [def:0001] [use:0001] */          //trace_PC(0x603F);
/* 068 [def:0001] [use:0001] */      case 0x6041: L_6041: //09 40 85
/* 069 [def:0001] [use:0001] */          A |= 0x40;
/* 070 [def:1800] [use:0008] */  //      ZN = A;
/* 071 [def:0001] [use:0001] */          //trace_PC(0x6041);
/* 072 [def:0001] [use:0001] */      case 0x6043: L_6043: //85 04 8D
/* 073 [def:0001] [use:0008] */          ram[0x0004] = A;
/* 074 [def:0001] [use:0001] */          //trace_PC(0x6043);
/* 075 [def:0001] [use:0001] */      case 0x6045: L_6045: //8D 00 30
/* 076 [def:0001] [use:0008] */          ram[0x3000] = A;
/* 077 [def:0001] [use:0001] */          //trace_PC(0x6045);
/* 078 [def:0001] [use:0001] */      case 0x6048: L_6048: //8D 00 34
/* 079 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 080 [def:0001] [use:0001] */          //trace_PC(0x6048);
/* 081 [def:0001] [use:0001] */      case 0x604B: L_604b: //E6 76 D0
/* 082 [def:1801] [use:0001] */          ZN=++ram[0x0076];
/* 083 [def:0001] [use:0001] */          //trace_PC(0x604B);
/* 084 [def:0001] [use:0001] */      case 0x604D: L_604d: //D0 30 E6
/* 085 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 086 [def:0001] [use:0001] */          {
/* 087 [def:0001] [use:0001] */              //trace_PC(0x604D);
/* 088 [def:0001] [use:0001] */              PC = 0x607f;
/*                           */              clockticks += 76;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x604D);
/* 002 [def:0001] [use:0001] */      case 0x604F: L_604f: //E6 77 A6
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x0077];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x604F);
/* 005 [def:0001] [use:0001] */      case 0x6051: L_6051: //A6 20 B5
/* 006 [def:0001] [use:0001] */          X=ram[0x0020];
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6051);
/* 009 [def:0001] [use:0001] */      case 0x6053: L_6053: //B5 64 29
/* 010 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x64 + X)];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6053);
/* 013 [def:0001] [use:0001] */      case 0x6055: L_6055: //29 0F 85
/* 014 [def:0009] [use:0008] */          A &= 0x0F;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6055);
/* 017 [def:0001] [use:0001] */      case 0x6057: L_6057: //85 10 55
/* 018 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6057);
/* 020 [def:0001] [use:0001] */      case 0x6059: L_6059: //55 64 4A
/* 021 [def:0001] [use:0011] */          temp=(0x0064 + X)&0xFF;
/* 022 [def:0001] [use:0001] */          ZN=ram[temp];
/* 023 [def:0001] [use:0001] */          A ^= ZN;
/* 024 [def:1800] [use:0008] */  //      ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6059);
/* 026 [def:0001] [use:0001] */      case 0x605B: L_605b: //4A 85 11
/* 027 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 028 [def:0009] [use:0008] */          A = A >> 1;
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x605B);
/* 031 [def:0001] [use:0001] */      case 0x605C: L_605c: //85 11 4A
/* 032 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x605C);
/* 034 [def:0001] [use:0001] */      case 0x605E: L_605e: //4A 4A 65
/* 035 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 036 [def:0009] [use:0008] */          A = A >> 1;
/* 037 [def:1800] [use:0008] */  //      ZN = A;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x605E);
/* 039 [def:0001] [use:0001] */      case 0x605F: L_605f: //4A 65 11
/* 040 [def:2001] [use:0008] */          C = A & 0x01;
/* 041 [def:0009] [use:0008] */          A = A >> 1;
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x605F);
/* 044 [def:0001] [use:0001] */      case 0x6060: L_6060: //65 11 65
/* 045 [def:b801] [use:6001] */          ADC(ram[0x0011]);
/* 046 [def:0001] [use:0001] */          //trace_PC(0x6060);
/* 047 [def:0001] [use:0001] */      case 0x6062: L_6062: //65 10 A6
/* 048 [def:b801] [use:6001] */          ADC(ram[0x0010]);
/* 049 [def:0001] [use:0001] */          //trace_PC(0x6062);
/* 050 [def:0001] [use:0001] */      case 0x6064: L_6064: //A6 1F A4
/* 051 [def:0001] [use:0001] */          X=ram[0x001F];
/* 052 [def:1800] [use:0010] */  //      ZN = X;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6064);
/* 054 [def:0001] [use:0001] */      case 0x6066: L_6066: //A4 77 C0
/* 055 [def:0021] [use:0001] */          Y=ram[0x0077];
/* 056 [def:1800] [use:0020] */  //      ZN = Y;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x6066);
/* 058 [def:0001] [use:0001] */      case 0x6068: L_6068: //C0 80 D0
/* 059 [def:0101] [use:0001] */          ZN=0x80;
/* 060 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 061 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 062 [def:0001] [use:0001] */          //trace_PC(0x6068);
/* 063 [def:0001] [use:0001] */      case 0x606A: L_606a: //D0 08 D5
/* 064 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 065 [def:0001] [use:0001] */          {
/* 066 [def:0001] [use:0001] */              //trace_PC(0x606A);
/* 067 [def:0001] [use:0001] */              PC = 0x6074;
/*                           */              clockticks += 122;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x606A);
/* 002 [def:0001] [use:0001] */      case 0x6074: L_6074: //18 75 FB
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6074);
/* 005 [def:0001] [use:0001] */      case 0x6075: L_6075: //75 FB C9
/* 006 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0xFB + X)]); /* zero page */
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6075);
/* 008 [def:0001] [use:0001] */      case 0x6077: L_6077: //C9 10 90
/* 009 [def:0101] [use:0000] */          ZN=0x10;
/* 010 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 011 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6077);
/* 013 [def:0001] [use:0001] */      case 0x6079: L_6079: //90 02 A9
/* 014 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6079);
/* 017 [def:0001] [use:0001] */              PC = 0x607d;
/*                           */              clockticks += 133;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6079);
/* 002 [def:0001] [use:0001] */      case 0x607D: L_607d: //85 D3 20
/* 003 [def:0001] [use:0008] */          ram[0x00D3] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x607D);
/* 005 [def:0001] [use:0001] */      case 0x607F: L_607f: //20 FF 7A
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x81;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x607F);
/* 009 [def:0001] [use:0001] */          PC = 0x7aff;
/*                           */          clockticks += 140; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6082: L_6082: //20 E1 4B
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x84;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6082);
/* 004 [def:0001] [use:0001] */          PC = 0x4be1;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6085: L_6085: //B0 42 20
/* 001 [def:0001] [use:2001] */          if (C)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6085);
/* 004 [def:0001] [use:0001] */              PC = 0x60c9;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6085);
/* 002 [def:0001] [use:0001] */      case 0x6087: L_6087: //20 D4 6F
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x89;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6087);
/* 006 [def:0001] [use:0001] */          PC = 0x6fd4;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x608A: L_608a: //20 6B 65
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x8C;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x608A);
/* 004 [def:0001] [use:0001] */          PC = 0x656b;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x608D: L_608d: //10 1E 20
/* 001 [def:0001] [use:1001] */          if (ZN < 0)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x608D);
/* 004 [def:0001] [use:0001] */              PC = 0x60ad;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x608D);
/* 002 [def:0001] [use:0001] */      case 0x608F: L_608f: //20 9D 6C
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x91;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x608F);
/* 006 [def:0001] [use:0001] */          PC = 0x6c9d;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6092: L_6092: //B0 19 A5
/* 001 [def:0001] [use:2001] */          if (C)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6092);
/* 004 [def:0001] [use:0001] */              PC = 0x60ad;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6092);
/* 002 [def:0001] [use:0001] */      case 0x6094: L_6094: //A5 74 D0
/* 003 [def:0009] [use:0001] */          A=ram[0x0074];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6094);
/* 006 [def:0001] [use:0001] */      case 0x6096: L_6096: //D0 0F 20
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6096);
/* 010 [def:0001] [use:0001] */              PC = 0x60a7;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6096);
/* 002 [def:0001] [use:0001] */      case 0x6098: L_6098: //20 59 66
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x9A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6098);
/* 006 [def:0001] [use:0001] */          PC = 0x6659;
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x609B: L_609b: //20 97 64
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x9D;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x609B);
/* 004 [def:0001] [use:0001] */          PC = 0x6497;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x609E: L_609e: //20 10 68
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xA0;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x609E);
/* 004 [def:0001] [use:0001] */          PC = 0x6810;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60A1: L_60a1: //20 9E 4A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xA3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60A1);
/* 004 [def:0001] [use:0001] */          PC = 0x4a9e;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60A4: L_60a4: //20 22 63
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xA6;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60A4);
/* 004 [def:0001] [use:0001] */          PC = 0x6322;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60A7: L_60a7: //20 DC 66
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xA9;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60A7);
/* 004 [def:0001] [use:0001] */          PC = 0x66dc;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60AA: L_60aa: //20 F7 60
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xAC;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60AA);
/* 004 [def:0001] [use:0001] */          PC = 0x60f7;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60AD: L_60ad: //20 7E 6A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xAF;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60AD);
/* 004 [def:0001] [use:0001] */          PC = 0x6a7e;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60B0: L_60b0: //20 F6 6E
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xB2;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60B0);
/* 004 [def:0001] [use:0001] */          PC = 0x6ef6;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60B3: L_60b3: //A9 7F AA
/* 001 [def:0009] [use:0000] */          A=0x7F;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60B3);
/* 004 [def:0001] [use:0001] */      case 0x60B5: L_60b5: //AA 20 1F
/* 005 [def:0011] [use:0008] */          X=A;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x60B5);
/* 008 [def:0001] [use:0001] */      case 0x60B6: L_60b6: //20 1F 7A
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0xB8;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x60B6);
/* 012 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60B9: L_60b9: //20 DA 79
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xBB;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60B9);
/* 004 [def:0001] [use:0001] */          PC = 0x79da;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60BC: L_60bc: //AD EC 02
/* 001 [def:0009] [use:0001] */          A=ram[0x02EC];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60BC);
/* 004 [def:0001] [use:0001] */      case 0x60BF: L_60bf: //F0 03 CE
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x60BF);
/* 008 [def:0001] [use:0001] */              PC = 0x60c4;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60BF);
/* 002 [def:0001] [use:0001] */      case 0x60C1: L_60c1: //CE EC 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02EC];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x60C1);
/* 005 [def:0001] [use:0001] */      case 0x60C4: L_60c4: //0D E7 02
/* 006 [def:0001] [use:0001] */          A|=ram[0x02E7];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x60C4);
/* 009 [def:0001] [use:0001] */      case 0x60C7: L_60c7: //D0 03 4C
/* 010 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x60C7);
/* 013 [def:0001] [use:0001] */              PC = 0x60cc;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60C7);
/* 002 [def:0001] [use:0001] */      case 0x60C9: L_60c9: //4C 11 60
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60C9);
/* 004 [def:0001] [use:0001] */          PC = 0x6011;
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60CC: L_60cc: //4C 14 60
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60CC);
/* 002 [def:0001] [use:0001] */          PC = 0x6014;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60D0: L_60d0: //A5 42 25
/* 001 [def:0009] [use:0001] */          A=ram[0x0042];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60D0);
/* 004 [def:0001] [use:0001] */      case 0x60D2: L_60d2: //25 43 30
/* 005 [def:0009] [use:0009] */          A &= ram[0x0043];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x60D2);
/* 008 [def:0001] [use:0001] */      case 0x60D4: L_60d4: //30 03 4C
/* 009 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x60D4);
/* 012 [def:0001] [use:0001] */              PC = 0x60d9;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60D4);
/* 002 [def:0001] [use:0001] */      case 0x60D9: L_60d9: //18 60 A5
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x60D9);
/* 005 [def:0001] [use:0001] */      case 0x60DA: L_60da: //60 A5 8A
/* 006 [def:0001] [use:0001] */          //trace_PC(0x60DA);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 16; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60DB: L_60db: //A5 8A 05
/* 001 [def:0009] [use:0001] */          A=ram[0x008A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60DB);
/* 004 [def:0001] [use:0001] */      case 0x60DD: L_60dd: //05 13 10
/* 005 [def:0009] [use:0009] */          A|=ram[0x0013];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x60DD);
/* 008 [def:0001] [use:0001] */      case 0x60DF: L_60df: //10 07 A5
/* 009 [def:0001] [use:1001] */          if (ZN < 0)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x60DF);
/* 012 [def:0001] [use:0001] */              PC = 0x60e8;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60DF);
/* 002 [def:0001] [use:0001] */      case 0x60E1: L_60e1: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x60E1);
/* 006 [def:0001] [use:0001] */      case 0x60E3: L_60e3: //29 20 F0
/* 007 [def:0009] [use:0008] */          A &= 0x20;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x60E3);
/* 010 [def:0001] [use:0001] */      case 0x60E5: L_60e5: //F0 01 60
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x60E5);
/* 014 [def:0001] [use:0001] */              PC = 0x60e8;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60E5);
/* 002 [def:0001] [use:0001] */      case 0x60E7: L_60e7: //60 4C 59
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60E7);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60E8: L_60e8: //4C 59 71
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60E8);
/* 002 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60EB: L_60eb: //A0 01 20
/* 001 [def:0021] [use:0000] */          Y=0x01;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60EB);
/* 004 [def:0001] [use:0001] */      case 0x60ED: L_60ed: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xEF;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x60ED);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60F0: L_60f0: //A4 1E C8
/* 001 [def:0021] [use:0001] */          Y=ram[0x001E];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x60F0);
/* 004 [def:0001] [use:0001] */      case 0x60F2: L_60f2: //C8 98 4C
/* 005 [def:0021] [use:0020] */          Y++;
/* 006 [def:1800] [use:0020] */  //      ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x60F2);
/* 008 [def:0001] [use:0001] */      case 0x60F3: L_60f3: //98 4C EB
/* 009 [def:0001] [use:0001] */          A=Y;
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x60F3);
/* 012 [def:0001] [use:0001] */      case 0x60F4: L_60f4: //4C EB 79
/* 013 [def:0001] [use:0001] */          //trace_PC(0x60F4);
/* 014 [def:0001] [use:0001] */          PC = 0x79eb;
/*                           */          clockticks += 10; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x60F7: L_60f7: //46 71 A2
/* 001 [def:0101] [use:0001] */          ZN=ram[0x0071];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 003 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 004 [def:0001] [use:0100] */          ram[0x0071] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x60F7);
/* 006 [def:0001] [use:0001] */      case 0x60F9: L_60f9: //A2 07 BD
/* 007 [def:0001] [use:0001] */          X=0x07;
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x60F9);
/* 010 [def:0001] [use:0001] */      case 0x60FB: L_60fb: //BD 19 02
/* 011 [def:0009] [use:0011] */          A=ram[0x0219 + X /* can't wrap */];
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x60FB);
/* 014 [def:0001] [use:0001] */      case 0x60FE: L_60fe: //F0 02 10
/* 015 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x60FE);
/* 018 [def:0001] [use:0001] */              PC = 0x6102;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x60FE);
/* 002 [def:0001] [use:0001] */      case 0x6100: L_6100: //10 0A CA
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6100);
/* 006 [def:0001] [use:0001] */              PC = 0x610c;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6100);
/* 002 [def:0001] [use:0001] */      case 0x6102: L_6102: //CA 10 F6
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6102);
/* 006 [def:0001] [use:0001] */      case 0x6103: L_6103: //10 F6 24
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6103);
/* 010 [def:0001] [use:0001] */              PC = 0x60fb;
/*                           */              clockticks += 21;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6103);
/* 002 [def:0001] [use:0001] */      case 0x6105: L_6105: //24 71 30
/* 003 [def:1101] [use:0001] */          ZN=ram[0x0071];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 004 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 005 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6105);
/* 007 [def:0001] [use:0001] */      case 0x6107: L_6107: //30 02 86
/* 008 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6107);
/* 011 [def:0001] [use:0001] */              PC = 0x610b;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6107);
/* 002 [def:0001] [use:0001] */      case 0x6109: L_6109: //86 72 60
/* 003 [def:0001] [use:0001] */          ram[0x0072] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6109);
/* 005 [def:0001] [use:0001] */      case 0x610B: L_610b: //60 A0 1A
/* 006 [def:0001] [use:0001] */          //trace_PC(0x610B);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 33; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x610C: L_610c: //A0 1A E0
/* 001 [def:0021] [use:0000] */          Y=0x1A;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x610C);
/* 004 [def:0001] [use:0001] */      case 0x610E: L_610e: //E0 04 B0
/* 005 [def:0101] [use:0000] */          ZN=0x04;
/* 006 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 007 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x610E);
/* 009 [def:0001] [use:0001] */      case 0x6110: L_6110: //B0 07 88
/* 010 [def:0001] [use:2001] */          if (C)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6110);
/* 013 [def:0001] [use:0001] */              PC = 0x6119;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6110);
/* 002 [def:0001] [use:0001] */      case 0x6112: L_6112: //88 8A D0
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6112);
/* 006 [def:0001] [use:0001] */      case 0x6113: L_6113: //8A D0 03
/* 007 [def:0001] [use:0001] */          A=X;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6113);
/* 010 [def:0001] [use:0001] */      case 0x6114: L_6114: //D0 03 88
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6114);
/* 014 [def:0001] [use:0001] */              PC = 0x6119;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6114);
/* 002 [def:0001] [use:0001] */      case 0x6116: L_6116: //88 30 E9
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6116);
/* 006 [def:0001] [use:0001] */      case 0x6117: L_6117: //30 E9 B9
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6117);
/* 010 [def:0001] [use:0001] */              PC = 0x6102;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6117);
/* 002 [def:0001] [use:0001] */      case 0x6119: L_6119: //B9 00 02
/* 003 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6119);
/* 006 [def:0001] [use:0001] */      case 0x611C: L_611c: //F0 F8 30
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x611C);
/* 010 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x611C);
/* 002 [def:0001] [use:0001] */      case 0x611E: L_611e: //30 F6 85
/* 003 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x611E);
/* 006 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x611E);
/* 002 [def:0001] [use:0001] */      case 0x6120: L_6120: //85 0C B9
/* 003 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6120);
/* 005 [def:0001] [use:0001] */      case 0x6122: L_6122: //B9 63 02
/* 006 [def:0009] [use:0021] */          A=ram[0x0263 + Y /* can't wrap */];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6122);
/* 009 [def:0001] [use:0001] */      case 0x6125: L_6125: //38 FD 7C
/* 010 [def:2001] [use:0000] */          C = 1;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6125);
/* 012 [def:0001] [use:0001] */      case 0x6126: L_6126: //FD 7C 02
/* 013 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x027C + X)]);
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6126);
/* 015 [def:0001] [use:0001] */      case 0x6129: L_6129: //E9 03 C9
/* 016 [def:b809] [use:6009] */          SBC(0x03);
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6129);
/* 018 [def:0001] [use:0001] */      case 0x612B: L_612b: //C9 FA 90
/* 019 [def:0101] [use:0000] */          ZN=0xFA;
/* 020 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 021 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x612B);
/* 023 [def:0001] [use:0001] */      case 0x612D: L_612d: //90 E7 B9
/* 024 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 025 [def:0001] [use:0001] */          {
/* 026 [def:0001] [use:0001] */              //trace_PC(0x612D);
/* 027 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 47;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x612D);
/* 002 [def:0001] [use:0001] */      case 0x612F: L_612f: //B9 84 02
/* 003 [def:0009] [use:0021] */          A=ram[0x0284 + Y /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x612F);
/* 006 [def:0001] [use:0001] */      case 0x6132: L_6132: //FD 9D 02
/* 007 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x029D + X)]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6132);
/* 009 [def:0001] [use:0001] */      case 0x6135: L_6135: //E9 03 C9
/* 010 [def:b809] [use:6009] */          SBC(0x03);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6135);
/* 012 [def:0001] [use:0001] */      case 0x6137: L_6137: //C9 FA 90
/* 013 [def:0101] [use:0000] */          ZN=0xFA;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6137);
/* 017 [def:0001] [use:0001] */      case 0x6139: L_6139: //90 DB B9
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x6139);
/* 021 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 63;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6139);
/* 002 [def:0001] [use:0001] */      case 0x613B: L_613b: //B9 A5 02
/* 003 [def:0009] [use:0021] */          A=ram[0x02A5 + Y /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x613B);
/* 006 [def:0001] [use:0001] */      case 0x613E: L_613e: //38 FD BE
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x613E);
/* 009 [def:0001] [use:0001] */      case 0x613F: L_613f: //FD BE 02
/* 010 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x02BE + X)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x613F);
/* 012 [def:0001] [use:0001] */      case 0x6142: L_6142: //85 09 B9
/* 013 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6142);
/* 015 [def:0001] [use:0001] */      case 0x6144: L_6144: //B9 63 02
/* 016 [def:0009] [use:0021] */          A=ram[0x0263 + Y /* can't wrap */];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6144);
/* 019 [def:0001] [use:0001] */      case 0x6147: L_6147: //FD 7C 02
/* 020 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x027C + X)]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6147);
/* 022 [def:0001] [use:0001] */      case 0x614A: L_614a: //4A 66 09
/* 023 [def:2001] [use:0008] */          C = A & 0x01;
/* 024 [def:0009] [use:0008] */          A = A >> 1;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x614A);
/* 027 [def:0001] [use:0001] */      case 0x614B: L_614b: //66 09 0A
/* 028 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 029 [def:0101] [use:0001] */          ZN=ram[0x0009];
/* 030 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 031 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 032 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 033 [def:0001] [use:0100] */          ram[0x0009] = ZN;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x614B);
/* 035 [def:0001] [use:0001] */      case 0x614D: L_614d: //0A F0 0E
/* 036 [def:2001] [use:0008] */          C = A & 0x80;
/* 037 [def:0009] [use:0008] */          A = A << 1;
/* 038 [def:1801] [use:0008] */          ZN = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x614D);
/* 040 [def:0001] [use:0001] */      case 0x614E: L_614e: //F0 0E 10
/* 041 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 042 [def:0001] [use:0001] */          {
/* 043 [def:0001] [use:0001] */              //trace_PC(0x614E);
/* 044 [def:0001] [use:0001] */              PC = 0x615e;
/*                           */              clockticks += 94;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x614E);
/* 002 [def:0001] [use:0001] */      case 0x6150: L_6150: //10 C4 49
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6150);
/* 006 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 96;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6150);
/* 002 [def:0001] [use:0001] */      case 0x6152: L_6152: //49 FE D0
/* 003 [def:0009] [use:0008] */          A ^= 0xFE;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6152);
/* 006 [def:0001] [use:0001] */      case 0x6154: L_6154: //D0 C0 A5
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6154);
/* 010 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 101;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6154);
/* 002 [def:0001] [use:0001] */      case 0x6156: L_6156: //A5 09 49
/* 003 [def:0009] [use:0001] */          A=ram[0x0009];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6156);
/* 006 [def:0001] [use:0001] */      case 0x6158: L_6158: //49 FF 69
/* 007 [def:0009] [use:0008] */          A ^= 0xFF;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6158);
/* 010 [def:0001] [use:0001] */      case 0x615A: L_615a: //69 00 85
/* 011 [def:b801] [use:6001] */          ADC(0x00);
/* 012 [def:0001] [use:0001] */          //trace_PC(0x615A);
/* 013 [def:0001] [use:0001] */      case 0x615C: L_615c: //85 09 B9
/* 014 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x615C);
/* 016 [def:0001] [use:0001] */      case 0x615E: L_615e: //B9 C6 02
/* 017 [def:0009] [use:0021] */          A=ram[0x02C6 + Y /* can't wrap */];
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x615E);
/* 020 [def:0001] [use:0001] */      case 0x6161: L_6161: //38 FD DF
/* 021 [def:2001] [use:0000] */          C = 1;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6161);
/* 023 [def:0001] [use:0001] */      case 0x6162: L_6162: //FD DF 02
/* 024 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x02DF + X)]);
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6162);
/* 026 [def:0001] [use:0001] */      case 0x6165: L_6165: //85 0A B9
/* 027 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6165);
/* 029 [def:0001] [use:0001] */      case 0x6167: L_6167: //B9 84 02
/* 030 [def:0009] [use:0021] */          A=ram[0x0284 + Y /* can't wrap */];
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x6167);
/* 033 [def:0001] [use:0001] */      case 0x616A: L_616a: //FD 9D 02
/* 034 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x029D + X)]);
/* 035 [def:0001] [use:0001] */          //trace_PC(0x616A);
/* 036 [def:0001] [use:0001] */      case 0x616D: L_616d: //4A 66 0A
/* 037 [def:2001] [use:0008] */          C = A & 0x01;
/* 038 [def:0009] [use:0008] */          A = A >> 1;
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x616D);
/* 041 [def:0001] [use:0001] */      case 0x616E: L_616e: //66 0A 0A
/* 042 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 043 [def:0101] [use:0001] */          ZN=ram[0x000A];
/* 044 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 045 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 046 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 047 [def:0001] [use:0100] */          ram[0x000A] = ZN;
/* 048 [def:0001] [use:0001] */          //trace_PC(0x616E);
/* 049 [def:0001] [use:0001] */      case 0x6170: L_6170: //0A F0 0E
/* 050 [def:2001] [use:0008] */          C = A & 0x80;
/* 051 [def:0009] [use:0008] */          A = A << 1;
/* 052 [def:1801] [use:0008] */          ZN = A;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6170);
/* 054 [def:0001] [use:0001] */      case 0x6171: L_6171: //F0 0E 10
/* 055 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 056 [def:0001] [use:0001] */          {
/* 057 [def:0001] [use:0001] */              //trace_PC(0x6171);
/* 058 [def:0001] [use:0001] */              PC = 0x6181;
/*                           */              clockticks += 143;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6171);
/* 002 [def:0001] [use:0001] */      case 0x6173: L_6173: //10 A1 49
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6173);
/* 006 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 145;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6173);
/* 002 [def:0001] [use:0001] */      case 0x6175: L_6175: //49 FE D0
/* 003 [def:0009] [use:0008] */          A ^= 0xFE;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6175);
/* 006 [def:0001] [use:0001] */      case 0x6177: L_6177: //D0 9D A5
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6177);
/* 010 [def:0001] [use:0001] */              PC = 0x6116;
/*                           */              clockticks += 150;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6177);
/* 002 [def:0001] [use:0001] */      case 0x6179: L_6179: //A5 0A 49
/* 003 [def:0009] [use:0001] */          A=ram[0x000A];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6179);
/* 006 [def:0001] [use:0001] */      case 0x617B: L_617b: //49 FF 69
/* 007 [def:0009] [use:0008] */          A ^= 0xFF;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x617B);
/* 010 [def:0001] [use:0001] */      case 0x617D: L_617d: //69 00 85
/* 011 [def:b801] [use:6001] */          ADC(0x00);
/* 012 [def:0001] [use:0001] */          //trace_PC(0x617D);
/* 013 [def:0001] [use:0001] */      case 0x617F: L_617f: //85 0A A9
/* 014 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x617F);
/* 016 [def:0001] [use:0001] */      case 0x6181: L_6181: //A9 04 E0
/* 017 [def:0009] [use:0000] */          A=0x04;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6181);
/* 020 [def:0001] [use:0001] */      case 0x6183: L_6183: //E0 01 F0
/* 021 [def:0101] [use:0000] */          ZN=0x01;
/* 022 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 023 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6183);
/* 025 [def:0001] [use:0001] */      case 0x6185: L_6185: //F0 07 B0
/* 026 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x6185);
/* 029 [def:0001] [use:0001] */              PC = 0x618e;
/*                           */              clockticks += 169;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6185);
/* 002 [def:0001] [use:0001] */      case 0x6187: L_6187: //B0 08 20
/* 003 [def:0001] [use:2001] */          if (C)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6187);
/* 006 [def:0001] [use:0001] */              PC = 0x6191;
/*                           */              clockticks += 171;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6187);
/* 002 [def:0001] [use:0001] */      case 0x6189: L_6189: //20 D5 61
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x61;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x8B;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6189);
/* 006 [def:0001] [use:0001] */          PC = 0x61d5;
/*                           */          clockticks += 176; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x618C: L_618c: //D0 03 20
/* 001 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x618C);
/* 004 [def:0001] [use:0001] */              PC = 0x6191;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x618C);
/* 002 [def:0001] [use:0001] */      case 0x618E: L_618e: //20 DE 61
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x61;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x90;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x618E);
/* 006 [def:0001] [use:0001] */          PC = 0x61de;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6191: L_6191: //C0 19 B0
/* 001 [def:0101] [use:0001] */          ZN=0x19;
/* 002 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 003 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6191);
/* 005 [def:0001] [use:0001] */      case 0x6193: L_6193: //B0 10 69
/* 006 [def:0001] [use:2001] */          if (C)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6193);
/* 009 [def:0001] [use:0001] */              PC = 0x61a5;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6193);
/* 002 [def:0001] [use:0001] */      case 0x6195: L_6195: //69 2A 46
/* 003 [def:b801] [use:6001] */          ADC(0x2A);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6195);
/* 005 [def:0001] [use:0001] */      case 0x6197: L_6197: //46 0C B0
/* 006 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 007 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 008 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 009 [def:0001] [use:0100] */          ram[0x000C] = ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6197);
/* 011 [def:0001] [use:0001] */      case 0x6199: L_6199: //B0 14 69
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6199);
/* 015 [def:0001] [use:0001] */              PC = 0x61af;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6199);
/* 002 [def:0001] [use:0001] */      case 0x619B: L_619b: //69 1E 46
/* 003 [def:b801] [use:6001] */          ADC(0x1E);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x619B);
/* 005 [def:0001] [use:0001] */      case 0x619D: L_619d: //46 0C B0
/* 006 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 007 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 008 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 009 [def:0001] [use:0100] */          ram[0x000C] = ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x619D);
/* 011 [def:0001] [use:0001] */      case 0x619F: L_619f: //B0 0E 69
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x619F);
/* 015 [def:0001] [use:0001] */              PC = 0x61af;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x619F);
/* 002 [def:0001] [use:0001] */      case 0x61A1: L_61a1: //69 3C 90
/* 003 [def:b801] [use:6001] */          ADC(0x3C);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61A1);
/* 005 [def:0001] [use:0001] */      case 0x61A3: L_61a3: //90 0A F0
/* 006 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x61A3);
/* 009 [def:0001] [use:0001] */              PC = 0x61af;
/*                           */              clockticks += 31;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61A3);
/* 002 [def:0001] [use:0001] */      case 0x61A5: L_61a5: //F0 05 20
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x61A5);
/* 006 [def:0001] [use:0001] */              PC = 0x61ac;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61A5);
/* 002 [def:0001] [use:0001] */      case 0x61A7: L_61a7: //20 DE 61
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x61;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xA9;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x61A7);
/* 006 [def:0001] [use:0001] */          PC = 0x61de;
/*                           */          clockticks += 38; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61AA: L_61aa: //D0 03 20
/* 001 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x61AA);
/* 004 [def:0001] [use:0001] */              PC = 0x61af;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61AA);
/* 002 [def:0001] [use:0001] */      case 0x61AC: L_61ac: //20 D5 61
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x61;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xAE;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x61AC);
/* 006 [def:0001] [use:0001] */          PC = 0x61d5;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61AF: L_61af: //C5 09 90
/* 001 [def:0001] [use:0001] */          ZN=ram[0x0009];
/* 002 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 003 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61AF);
/* 005 [def:0001] [use:0001] */      case 0x61B1: L_61b1: //90 1F C5
/* 006 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x61B1);
/* 009 [def:0001] [use:0001] */              PC = 0x61d2;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61B1);
/* 002 [def:0001] [use:0001] */      case 0x61B3: L_61b3: //C5 0A 90
/* 003 [def:0001] [use:0001] */          ZN=ram[0x000A];
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x61B3);
/* 007 [def:0001] [use:0001] */      case 0x61B5: L_61b5: //90 1B 85
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x61B5);
/* 011 [def:0001] [use:0001] */              PC = 0x61d2;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61B5);
/* 002 [def:0001] [use:0001] */      case 0x61B7: L_61b7: //85 0C 4A
/* 003 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61B7);
/* 005 [def:0001] [use:0001] */      case 0x61B9: L_61b9: //4A 18 65
/* 006 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 007 [def:0009] [use:0008] */          A = A >> 1;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x61B9);
/* 010 [def:0001] [use:0001] */      case 0x61BA: L_61ba: //18 65 0C
/* 011 [def:2001] [use:0000] */          C = 0;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x61BA);
/* 013 [def:0001] [use:0001] */      case 0x61BB: L_61bb: //65 0C 6A
/* 014 [def:b801] [use:6001] */          ADC(ram[0x000C]);
/* 015 [def:0001] [use:0001] */          //trace_PC(0x61BB);
/* 016 [def:0001] [use:0001] */      case 0x61BD: L_61bd: //6A 85 0C
/* 017 [def:10001] [use:2000] */          saveflags = C;
/* 018 [def:2001] [use:0008] */          C = A & 0x01;
/* 019 [def:0009] [use:0008] */          A = A >> 1;
/* 020 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x61BD);
/* 023 [def:0001] [use:0001] */      case 0x61BE: L_61be: //85 0C A5
/* 024 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x61BE);
/* 026 [def:0001] [use:0001] */      case 0x61C0: L_61c0: //A5 0A 65
/* 027 [def:0009] [use:0001] */          A=ram[0x000A];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x61C0);
/* 030 [def:0001] [use:0001] */      case 0x61C2: L_61c2: //65 09 6A
/* 031 [def:b801] [use:6001] */          ADC(ram[0x0009]);
/* 032 [def:0001] [use:0001] */          //trace_PC(0x61C2);
/* 033 [def:0001] [use:0001] */      case 0x61C4: L_61c4: //6A C5 0C
/* 034 [def:10001] [use:2000] */          saveflags = C;
/* 035 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 036 [def:0009] [use:0008] */          A = A >> 1;
/* 037 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 038 [def:1801] [use:0008] */          ZN = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x61C4);
/* 040 [def:0001] [use:0001] */      case 0x61C5: L_61c5: //C5 0C B0
/* 041 [def:0001] [use:0001] */          ZN=ram[0x000C];
/* 042 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 043 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x61C5);
/* 045 [def:0001] [use:0001] */      case 0x61C7: L_61c7: //B0 09 8A
/* 046 [def:0001] [use:2001] */          if (C)
/* 047 [def:0001] [use:0001] */          {
/* 048 [def:0001] [use:0001] */              //trace_PC(0x61C7);
/* 049 [def:0001] [use:0001] */              PC = 0x61d2;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61C7);
/* 002 [def:0001] [use:0001] */      case 0x61C9: L_61c9: //8A 48 20
/* 003 [def:0001] [use:0001] */          A=X;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x61C9);
/* 006 [def:0001] [use:0001] */      case 0x61CA: L_61ca: //48 20 A1
/* 007 [def:0001] [use:0001] */          stack[S--] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x61CA);
/* 009 [def:0001] [use:0001] */      case 0x61CB: L_61cb: //20 A1 62
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x61;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0xCD;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x61CB);
/* 013 [def:0001] [use:0001] */          PC = 0x62a1;
/*                           */          clockticks += 47; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61CE: L_61ce: //68 AA A0
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x61CE);
/* 004 [def:0001] [use:0001] */      case 0x61CF: L_61cf: //AA A0 00
/* 005 [def:0011] [use:0008] */          X=A;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x61CF);
/* 008 [def:0001] [use:0001] */      case 0x61D0: L_61d0: //A0 00 4C
/* 009 [def:0021] [use:0000] */          Y=0x00;
/* 010 [def:1801] [use:0020] */          ZN = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x61D0);
/* 012 [def:0001] [use:0001] */      case 0x61D2: L_61d2: //4C 16 61
/* 013 [def:0001] [use:0001] */          //trace_PC(0x61D2);
/* 014 [def:0001] [use:0001] */          PC = 0x6116;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61D5: L_61d5: //24 73 10
/* 001 [def:1101] [use:0001] */          ZN=ram[0x0073];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61D5);
/* 005 [def:0001] [use:0001] */      case 0x61D7: L_61d7: //10 02 69
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x61D7);
/* 009 [def:0001] [use:0001] */              PC = 0x61db;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61D7);
/* 002 [def:0001] [use:0001] */      case 0x61D9: L_61d9: //69 08 69
/* 003 [def:b801] [use:6001] */          ADC(0x08);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61D9);
/* 005 [def:0001] [use:0001] */      case 0x61DB: L_61db: //69 1C 60
/* 006 [def:b801] [use:6001] */          ADC(0x1C);
/* 007 [def:0001] [use:0001] */          //trace_PC(0x61DB);
/* 008 [def:0001] [use:0001] */      case 0x61DD: L_61dd: //60 69 1C
/* 009 [def:0001] [use:0001] */          //trace_PC(0x61DD);
/* 010 [def:0001] [use:0001] */          PC=stack[++S];
/* 011 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 012 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61DE: L_61de: //69 1C 48
/* 001 [def:b801] [use:6001] */          ADC(0x1C);
/* 002 [def:0001] [use:0001] */          //trace_PC(0x61DE);
/* 003 [def:0001] [use:0001] */      case 0x61E0: L_61e0: //48 AD 1A
/* 004 [def:0001] [use:0001] */          stack[S--] = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x61E0);
/* 006 [def:0001] [use:0001] */      case 0x61E1: L_61e1: //AD 1A 02
/* 007 [def:0009] [use:0001] */          A=ram[0x021A];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x61E1);
/* 010 [def:0001] [use:0001] */      case 0x61E4: L_61e4: //4A 68 B0
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x61E4);
/* 015 [def:0001] [use:0001] */      case 0x61E5: L_61e5: //68 B0 02
/* 016 [def:0001] [use:0001] */          A=stack[++S];
/* 017 [def:1801] [use:0008] */          ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x61E5);
/* 019 [def:0001] [use:0001] */      case 0x61E6: L_61e6: //B0 02 69
/* 020 [def:0001] [use:2001] */          if (C)
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x61E6);
/* 023 [def:0001] [use:0001] */              PC = 0x61ea;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x61E6);
/* 002 [def:0001] [use:0001] */      case 0x61E8: L_61e8: //69 12 60
/* 003 [def:b801] [use:6001] */          ADC(0x12);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x61E8);
/* 005 [def:0001] [use:0001] */      case 0x61EA: L_61ea: //60 B9 00
/* 006 [def:0001] [use:0001] */          //trace_PC(0x61EA);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x61EB: L_61eb: //B9 00 02
/* 001 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x61EB);
/* 004 [def:0001] [use:0001] */      case 0x61EE: L_61ee: //29 07 85
/* 005 [def:0009] [use:0008] */          A &= 0x07;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x61EE);
/* 008 [def:0001] [use:0001] */      case 0x61F0: L_61f0: //85 09 AD
/* 009 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x61F0);
/* 011 [def:0001] [use:0001] */      case 0x61F2: L_61f2: //AD 0A 2C
/* 012 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x61F2);
/* 015 [def:0001] [use:0001] */      case 0x61F5: L_61f5: //29 18 05
/* 016 [def:0009] [use:0008] */          A &= 0x18;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x61F5);
/* 019 [def:0001] [use:0001] */      case 0x61F7: L_61f7: //05 09 9D
/* 020 [def:0009] [use:0009] */          A|=ram[0x0009];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x61F7);
/* 023 [def:0001] [use:0001] */      case 0x61F9: L_61f9: //9D 00 02
/* 024 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x61F9);
/* 026 [def:0001] [use:0001] */      case 0x61FC: L_61fc: //B9 A5 02
/* 027 [def:0009] [use:0021] */          A=ram[0x02A5 + Y /* can't wrap */];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x61FC);
/* 030 [def:0001] [use:0001] */      case 0x61FF: L_61ff: //9D A5 02
/* 031 [def:0001] [use:0019] */          ram[0x02A5 + X /* can't wrap */] = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x61FF);
/* 033 [def:0001] [use:0001] */      case 0x6202: L_6202: //B9 63 02
/* 034 [def:0009] [use:0021] */          A=ram[0x0263 + Y /* can't wrap */];
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x6202);
/* 037 [def:0001] [use:0001] */      case 0x6205: L_6205: //9D 63 02
/* 038 [def:0001] [use:0019] */          ram[0x0263 + X /* can't wrap */] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6205);
/* 040 [def:0001] [use:0001] */      case 0x6208: L_6208: //B9 C6 02
/* 041 [def:0009] [use:0021] */          A=ram[0x02C6 + Y /* can't wrap */];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x6208);
/* 044 [def:0001] [use:0001] */      case 0x620B: L_620b: //9D C6 02
/* 045 [def:0001] [use:0019] */          ram[0x02C6 + X /* can't wrap */] = A;
/* 046 [def:0001] [use:0001] */          //trace_PC(0x620B);
/* 047 [def:0001] [use:0001] */      case 0x620E: L_620e: //B9 84 02
/* 048 [def:0009] [use:0021] */          A=ram[0x0284 + Y /* can't wrap */];
/* 049 [def:1800] [use:0008] */  //      ZN = A;
/* 050 [def:0001] [use:0001] */          //trace_PC(0x620E);
/* 051 [def:0001] [use:0001] */      case 0x6211: L_6211: //9D 84 02
/* 052 [def:0001] [use:0019] */          ram[0x0284 + X /* can't wrap */] = A;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6211);
/* 054 [def:0001] [use:0001] */      case 0x6214: L_6214: //B9 21 02
/* 055 [def:0009] [use:0021] */          A=ram[0x0221 + Y /* can't wrap */];
/* 056 [def:1800] [use:0008] */  //      ZN = A;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x6214);
/* 058 [def:0001] [use:0001] */      case 0x6217: L_6217: //9D 21 02
/* 059 [def:0001] [use:0019] */          ram[0x0221 + X /* can't wrap */] = A;
/* 060 [def:0001] [use:0001] */          //trace_PC(0x6217);
/* 061 [def:0001] [use:0001] */      case 0x621A: L_621a: //B9 42 02
/* 062 [def:0009] [use:0021] */          A=ram[0x0242 + Y /* can't wrap */];
/* 063 [def:1801] [use:0008] */          ZN = A;
/* 064 [def:0001] [use:0001] */          //trace_PC(0x621A);
/* 065 [def:0001] [use:0001] */      case 0x621D: L_621d: //9D 42 02
/* 066 [def:0001] [use:0019] */          ram[0x0242 + X /* can't wrap */] = A;
/* 067 [def:0001] [use:0001] */          //trace_PC(0x621D);
/* 068 [def:0001] [use:0001] */      case 0x6220: L_6220: //60 A0 FF
/* 069 [def:0001] [use:0001] */          //trace_PC(0x6220);
/* 070 [def:0001] [use:0001] */          PC=stack[++S];
/* 071 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 072 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 84; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6221: L_6221: //A0 FF 24
/* 001 [def:0021] [use:0000] */          Y=0xFF;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6221);
/* 004 [def:0001] [use:0001] */      case 0x6223: L_6223: //24 12 30
/* 005 [def:1101] [use:0001] */          ZN=ram[0x0012];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 006 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 007 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6223);
/* 009 [def:0001] [use:0001] */      case 0x6225: L_6225: //30 2D C8
/* 010 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6225);
/* 013 [def:0001] [use:0001] */              PC = 0x6254;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6225);
/* 002 [def:0001] [use:0001] */      case 0x6227: L_6227: //C8 C8 B1
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6227);
/* 006 [def:0001] [use:0001] */      case 0x6228: L_6228: //C8 B1 10
/* 007 [def:0021] [use:0020] */          Y++;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6228);
/* 010 [def:0001] [use:0001] */      case 0x6229: L_6229: //B1 10 45
/* 011 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 012 [def:0001] [use:0001] */          temp<<=8;
/* 013 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 014 [def:0001] [use:0001] */          temp+=Y;
/* 015 [def:0001] [use:0001] */          A=ram[temp];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6229);
/* 018 [def:0001] [use:0001] */      case 0x622B: L_622b: //45 0A 91
/* 019 [def:0001] [use:0001] */          A^=ram[0x000A];
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x622B);
/* 022 [def:0001] [use:0001] */      case 0x622D: L_622d: //91 03 88
/* 023 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 024 [def:0001] [use:0001] */          //trace_PC(0x622D);
/* 025 [def:0001] [use:0001] */      case 0x622F: L_622f: //88 C9 F0
/* 026 [def:0021] [use:0020] */          Y--;
/* 027 [def:1800] [use:0020] */  //      ZN = Y;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x622F);
/* 029 [def:0001] [use:0001] */      case 0x6230: L_6230: //C9 F0 B0
/* 030 [def:0101] [use:0000] */          ZN=0xF0;
/* 031 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 032 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6230);
/* 034 [def:0001] [use:0001] */      case 0x6232: L_6232: //B0 17 B1
/* 035 [def:0001] [use:2001] */          if (C)
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x6232);
/* 038 [def:0001] [use:0001] */              PC = 0x624b;
/*                           */              clockticks += 34;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6232);
/* 002 [def:0001] [use:0001] */      case 0x6234: L_6234: //B1 10 91
/* 003 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 004 [def:0001] [use:0001] */          temp<<=8;
/* 005 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 006 [def:0001] [use:0001] */          temp+=Y;
/* 007 [def:0001] [use:0001] */          A=ram[temp];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6234);
/* 010 [def:0001] [use:0001] */      case 0x6236: L_6236: //91 03 C8
/* 011 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6236);
/* 013 [def:0001] [use:0001] */      case 0x6238: L_6238: //C8 C8 B1
/* 014 [def:0021] [use:0020] */          Y++;
/* 015 [def:1800] [use:0020] */  //      ZN = Y;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6238);
/* 017 [def:0001] [use:0001] */      case 0x6239: L_6239: //C8 B1 10
/* 018 [def:0021] [use:0020] */          Y++;
/* 019 [def:1800] [use:0020] */  //      ZN = Y;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6239);
/* 021 [def:0001] [use:0001] */      case 0x623A: L_623a: //B1 10 91
/* 022 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 023 [def:0001] [use:0001] */          temp<<=8;
/* 024 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 025 [def:0001] [use:0001] */          temp+=Y;
/* 026 [def:0001] [use:0001] */          A=ram[temp];
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x623A);
/* 029 [def:0001] [use:0001] */      case 0x623C: L_623c: //91 03 C8
/* 030 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 031 [def:0001] [use:0001] */          //trace_PC(0x623C);
/* 032 [def:0001] [use:0001] */      case 0x623E: L_623e: //C8 B1 10
/* 033 [def:0021] [use:0020] */          Y++;
/* 034 [def:1800] [use:0020] */  //      ZN = Y;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x623E);
/* 036 [def:0001] [use:0001] */      case 0x623F: L_623f: //B1 10 45
/* 037 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 038 [def:0001] [use:0001] */          temp<<=8;
/* 039 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 040 [def:0001] [use:0001] */          temp+=Y;
/* 041 [def:0001] [use:0001] */          A=ram[temp];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x623F);
/* 044 [def:0001] [use:0001] */      case 0x6241: L_6241: //45 09 91
/* 045 [def:0001] [use:0001] */          A^=ram[0x0009];
/* 046 [def:1800] [use:0008] */  //      ZN = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6241);
/* 048 [def:0001] [use:0001] */      case 0x6243: L_6243: //91 03 CA
/* 049 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 050 [def:0001] [use:0001] */          //trace_PC(0x6243);
/* 051 [def:0001] [use:0001] */      case 0x6245: L_6245: //CA 10 DF
/* 052 [def:0011] [use:0010] */          X--;
/* 053 [def:1801] [use:0010] */          ZN = X;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x6245);
/* 055 [def:0001] [use:0001] */      case 0x6246: L_6246: //10 DF 4C
/* 056 [def:0001] [use:1001] */          if (ZN < 0)
/* 057 [def:0001] [use:0001] */          {
/* 058 [def:0001] [use:0001] */              //trace_PC(0x6246);
/* 059 [def:0001] [use:0001] */              PC = 0x6227;
/*                           */              clockticks += 80;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6246);
/* 002 [def:0001] [use:0001] */      case 0x6248: L_6248: //4C 55 7A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6248);
/* 004 [def:0001] [use:0001] */          PC = 0x7a55;
/*                           */          clockticks += 82; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x624B: L_624b: //B1 10 45
/* 001 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 002 [def:0001] [use:0001] */          temp<<=8;
/* 003 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 004 [def:0001] [use:0001] */          temp+=Y;
/* 005 [def:0001] [use:0001] */          A=ram[temp];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x624B);
/* 008 [def:0001] [use:0001] */      case 0x624D: L_624d: //45 09 91
/* 009 [def:0001] [use:0001] */          A^=ram[0x0009];
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x624D);
/* 012 [def:0001] [use:0001] */      case 0x624F: L_624f: //91 03 C8
/* 013 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 014 [def:0001] [use:0001] */          //trace_PC(0x624F);
/* 015 [def:0001] [use:0001] */      case 0x6251: L_6251: //C8 D0 F1
/* 016 [def:0021] [use:0020] */          Y++;
/* 017 [def:1801] [use:0020] */          ZN = Y;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6251);
/* 019 [def:0001] [use:0001] */      case 0x6252: L_6252: //D0 F1 C8
/* 020 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x6252);
/* 023 [def:0001] [use:0001] */              PC = 0x6245;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6252);
/* 002 [def:0001] [use:0001] */      case 0x6254: L_6254: //C8 B1 10
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6254);
/* 006 [def:0001] [use:0001] */      case 0x6255: L_6255: //B1 10 85
/* 007 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 008 [def:0001] [use:0001] */          temp<<=8;
/* 009 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 010 [def:0001] [use:0001] */          temp+=Y;
/* 011 [def:0001] [use:0001] */          A=ram[temp];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6255);
/* 014 [def:0001] [use:0001] */      case 0x6257: L_6257: //85 14 C8
/* 015 [def:0001] [use:0008] */          ram[0x0014] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6257);
/* 017 [def:0001] [use:0001] */      case 0x6259: L_6259: //C8 B1 10
/* 018 [def:0021] [use:0020] */          Y++;
/* 019 [def:1800] [use:0020] */  //      ZN = Y;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6259);
/* 021 [def:0001] [use:0001] */      case 0x625A: L_625a: //B1 10 C9
/* 022 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 023 [def:0001] [use:0001] */          temp<<=8;
/* 024 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 025 [def:0001] [use:0001] */          temp+=Y;
/* 026 [def:0001] [use:0001] */          A=ram[temp];
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x625A);
/* 029 [def:0001] [use:0001] */      case 0x625C: L_625c: //C9 F0 B0
/* 030 [def:0101] [use:0000] */          ZN=0xF0;
/* 031 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 032 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x625C);
/* 034 [def:0001] [use:0001] */      case 0x625E: L_625e: //B0 2C C8
/* 035 [def:0001] [use:2001] */          if (C)
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x625E);
/* 038 [def:0001] [use:0001] */              PC = 0x628c;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x625E);
/* 002 [def:0001] [use:0001] */      case 0x6260: L_6260: //C8 C8 51
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6260);
/* 006 [def:0001] [use:0001] */      case 0x6261: L_6261: //C8 51 10
/* 007 [def:0021] [use:0020] */          Y++;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6261);
/* 010 [def:0001] [use:0001] */      case 0x6262: L_6262: //51 10 29
/* 011 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0011]<<8)|ram[0x0010])+Y)]; /* Assume it won't wrap at 64K */
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6262);
/* 014 [def:0001] [use:0001] */      case 0x6264: L_6264: //29 0F 85
/* 015 [def:0009] [use:0008] */          A &= 0x0F;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6264);
/* 018 [def:0001] [use:0001] */      case 0x6266: L_6266: //85 13 51
/* 019 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6266);
/* 021 [def:0001] [use:0001] */      case 0x6268: L_6268: //51 10 45
/* 022 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0011]<<8)|ram[0x0010])+Y)]; /* Assume it won't wrap at 64K */
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6268);
/* 025 [def:0001] [use:0001] */      case 0x626A: L_626a: //45 09 91
/* 026 [def:0001] [use:0001] */          A^=ram[0x0009];
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x626A);
/* 029 [def:0001] [use:0001] */      case 0x626C: L_626c: //91 03 88
/* 030 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 031 [def:0001] [use:0001] */          //trace_PC(0x626C);
/* 032 [def:0001] [use:0001] */      case 0x626E: L_626e: //88 B1 10
/* 033 [def:0021] [use:0020] */          Y--;
/* 034 [def:1800] [use:0020] */  //      ZN = Y;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x626E);
/* 036 [def:0001] [use:0001] */      case 0x626F: L_626f: //B1 10 48
/* 037 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0010 + 1)];
/* 038 [def:0001] [use:0001] */          temp<<=8;
/* 039 [def:0001] [use:0001] */          temp|=ram[0x0010];
/* 040 [def:0001] [use:0001] */          temp+=Y;
/* 041 [def:0001] [use:0001] */          A=ram[temp];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x626F);
/* 044 [def:0001] [use:0001] */      case 0x6271: L_6271: //48 A5 14
/* 045 [def:0001] [use:0001] */          stack[S--] = A;
/* 046 [def:0001] [use:0001] */          //trace_PC(0x6271);
/* 047 [def:0001] [use:0001] */      case 0x6272: L_6272: //A5 14 91
/* 048 [def:0009] [use:0001] */          A=ram[0x0014];
/* 049 [def:1800] [use:0008] */  //      ZN = A;
/* 050 [def:0001] [use:0001] */          //trace_PC(0x6272);
/* 051 [def:0001] [use:0001] */      case 0x6274: L_6274: //91 03 88
/* 052 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6274);
/* 054 [def:0001] [use:0001] */      case 0x6276: L_6276: //88 A5 13
/* 055 [def:0021] [use:0020] */          Y--;
/* 056 [def:1800] [use:0020] */  //      ZN = Y;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x6276);
/* 058 [def:0001] [use:0001] */      case 0x6277: L_6277: //A5 13 45
/* 059 [def:0009] [use:0001] */          A=ram[0x0013];
/* 060 [def:1800] [use:0008] */  //      ZN = A;
/* 061 [def:0001] [use:0001] */          //trace_PC(0x6277);
/* 062 [def:0001] [use:0001] */      case 0x6279: L_6279: //45 0A 51
/* 063 [def:0001] [use:0001] */          A^=ram[0x000A];
/* 064 [def:1800] [use:0008] */  //      ZN = A;
/* 065 [def:0001] [use:0001] */          //trace_PC(0x6279);
/* 066 [def:0001] [use:0001] */      case 0x627B: L_627b: //51 10 91
/* 067 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0011]<<8)|ram[0x0010])+Y)]; /* Assume it won't wrap at 64K */
/* 068 [def:1800] [use:0008] */  //      ZN = A;
/* 069 [def:0001] [use:0001] */          //trace_PC(0x627B);
/* 070 [def:0001] [use:0001] */      case 0x627D: L_627d: //91 03 88
/* 071 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 072 [def:0001] [use:0001] */          //trace_PC(0x627D);
/* 073 [def:0001] [use:0001] */      case 0x627F: L_627f: //88 68 91
/* 074 [def:0021] [use:0020] */          Y--;
/* 075 [def:1800] [use:0020] */  //      ZN = Y;
/* 076 [def:0001] [use:0001] */          //trace_PC(0x627F);
/* 077 [def:0001] [use:0001] */      case 0x6280: L_6280: //68 91 03
/* 078 [def:0001] [use:0001] */          A=stack[++S];
/* 079 [def:1800] [use:0008] */  //      ZN = A;
/* 080 [def:0001] [use:0001] */          //trace_PC(0x6280);
/* 081 [def:0001] [use:0001] */      case 0x6281: L_6281: //91 03 C8
/* 082 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 083 [def:0001] [use:0001] */          //trace_PC(0x6281);
/* 084 [def:0001] [use:0001] */      case 0x6283: L_6283: //C8 C8 C8
/* 085 [def:0021] [use:0020] */          Y++;
/* 086 [def:1800] [use:0020] */  //      ZN = Y;
/* 087 [def:0001] [use:0001] */          //trace_PC(0x6283);
/* 088 [def:0001] [use:0001] */      case 0x6284: L_6284: //C8 C8 CA
/* 089 [def:0021] [use:0020] */          Y++;
/* 090 [def:1800] [use:0020] */  //      ZN = Y;
/* 091 [def:0001] [use:0001] */          //trace_PC(0x6284);
/* 092 [def:0001] [use:0001] */      case 0x6285: L_6285: //C8 CA 10
/* 093 [def:0021] [use:0020] */          Y++;
/* 094 [def:1800] [use:0020] */  //      ZN = Y;
/* 095 [def:0001] [use:0001] */          //trace_PC(0x6285);
/* 096 [def:0001] [use:0001] */      case 0x6286: L_6286: //CA 10 CB
/* 097 [def:0011] [use:0010] */          X--;
/* 098 [def:1801] [use:0010] */          ZN = X;
/* 099 [def:0001] [use:0001] */          //trace_PC(0x6286);
/* 100 [def:0001] [use:0001] */      case 0x6287: L_6287: //10 CB 4C
/* 101 [def:0001] [use:1001] */          if (ZN < 0)
/* 102 [def:0001] [use:0001] */          {
/* 103 [def:0001] [use:0001] */              //trace_PC(0x6287);
/* 104 [def:0001] [use:0001] */              PC = 0x6254;
/*                           */              clockticks += 128;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6287);
/* 002 [def:0001] [use:0001] */      case 0x6289: L_6289: //4C 55 7A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6289);
/* 004 [def:0001] [use:0001] */          PC = 0x7a55;
/*                           */          clockticks += 130; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x628C: L_628c: //45 14 29
/* 001 [def:0001] [use:0001] */          A^=ram[0x0014];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x628C);
/* 004 [def:0001] [use:0001] */      case 0x628E: L_628e: //29 07 48
/* 005 [def:0009] [use:0008] */          A &= 0x07;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x628E);
/* 008 [def:0001] [use:0001] */      case 0x6290: L_6290: //48 51 10
/* 009 [def:0001] [use:0001] */          stack[S--] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6290);
/* 011 [def:0001] [use:0001] */      case 0x6291: L_6291: //51 10 45
/* 012 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0011]<<8)|ram[0x0010])+Y)]; /* Assume it won't wrap at 64K */
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6291);
/* 015 [def:0001] [use:0001] */      case 0x6293: L_6293: //45 0A 91
/* 016 [def:0001] [use:0001] */          A^=ram[0x000A];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6293);
/* 019 [def:0001] [use:0001] */      case 0x6295: L_6295: //91 03 88
/* 020 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6295);
/* 022 [def:0001] [use:0001] */      case 0x6297: L_6297: //88 68 51
/* 023 [def:0021] [use:0020] */          Y--;
/* 024 [def:1800] [use:0020] */  //      ZN = Y;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6297);
/* 026 [def:0001] [use:0001] */      case 0x6298: L_6298: //68 51 10
/* 027 [def:0001] [use:0001] */          A=stack[++S];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6298);
/* 030 [def:0001] [use:0001] */      case 0x6299: L_6299: //51 10 45
/* 031 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0011]<<8)|ram[0x0010])+Y)]; /* Assume it won't wrap at 64K */
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6299);
/* 034 [def:0001] [use:0001] */      case 0x629B: L_629b: //45 09 91
/* 035 [def:0001] [use:0001] */          A^=ram[0x0009];
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x629B);
/* 038 [def:0001] [use:0001] */      case 0x629D: L_629d: //91 03 B0
/* 039 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 040 [def:0001] [use:0001] */          //trace_PC(0x629D);
/* 041 [def:0001] [use:0001] */      case 0x629F: L_629f: //B0 E4 20
/* 042 [def:0001] [use:2001] */          if (C)
/* 043 [def:0001] [use:0001] */          {
/* 044 [def:0001] [use:0001] */              //trace_PC(0x629F);
/* 045 [def:0001] [use:0001] */              PC = 0x6285;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x629F);
/* 002 [def:0001] [use:0001] */      case 0x62A1: L_62a1: //20 E7 74
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xA3;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62A1);
/* 006 [def:0001] [use:0001] */          PC = 0x74e7;
/*                           */          clockticks += 51; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x62A4: L_62a4: //B0 62 E0
/* 001 [def:0001] [use:2001] */          if (C)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x62A4);
/* 004 [def:0001] [use:0001] */              PC = 0x6308;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62A4);
/* 002 [def:0001] [use:0001] */      case 0x62A6: L_62a6: //E0 01 D0
/* 003 [def:0101] [use:0000] */          ZN=0x01;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x62A6);
/* 007 [def:0001] [use:0001] */      case 0x62A8: L_62a8: //D0 06 C0
/* 008 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x62A8);
/* 011 [def:0001] [use:0001] */              PC = 0x62b0;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62A8);
/* 002 [def:0001] [use:0001] */      case 0x62B0: L_62b0: //8A D0 16
/* 003 [def:0001] [use:0001] */          A=X;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62B0);
/* 006 [def:0001] [use:0001] */      case 0x62B1: L_62b1: //D0 16 20
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x62B1);
/* 010 [def:0001] [use:0001] */              PC = 0x62c9;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62B1);
/* 002 [def:0001] [use:0001] */      case 0x62B3: L_62b3: //20 F8 62
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xB5;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62B3);
/* 006 [def:0001] [use:0001] */          PC = 0x62f8;
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x62B6: L_62b6: //A9 A0 9D
/* 001 [def:0009] [use:0000] */          A=0xA0;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x62B6);
/* 004 [def:0001] [use:0001] */      case 0x62B8: L_62b8: //9D 19 02
/* 005 [def:0001] [use:0019] */          ram[0x0219 + X /* can't wrap */] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x62B8);
/* 007 [def:0001] [use:0001] */      case 0x62BB: L_62bb: //A9 00 9D
/* 008 [def:0009] [use:0000] */          A=0x00;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x62BB);
/* 011 [def:0001] [use:0001] */      case 0x62BD: L_62bd: //9D 3A 02
/* 012 [def:0001] [use:0019] */          ram[0x023A + X /* can't wrap */] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x62BD);
/* 014 [def:0001] [use:0001] */      case 0x62C0: L_62c0: //9D 5B 02
/* 015 [def:0001] [use:0019] */          ram[0x025B + X /* can't wrap */] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x62C0);
/* 017 [def:0001] [use:0001] */      case 0x62C3: L_62c3: //C0 19 90
/* 018 [def:0101] [use:0001] */          ZN=0x19;
/* 019 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 020 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x62C3);
/* 022 [def:0001] [use:0001] */      case 0x62C5: L_62c5: //90 0D B0
/* 023 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 024 [def:0001] [use:0001] */          {
/* 025 [def:0001] [use:0001] */              //trace_PC(0x62C5);
/* 026 [def:0001] [use:0001] */              PC = 0x62d4;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62C5);
/* 002 [def:0001] [use:0001] */      case 0x62C9: L_62c9: //A9 00 9D
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62C9);
/* 006 [def:0001] [use:0001] */      case 0x62CB: L_62cb: //9D 19 02
/* 007 [def:0001] [use:0019] */          ram[0x0219 + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x62CB);
/* 009 [def:0001] [use:0001] */      case 0x62CE: L_62ce: //C0 19 F0
/* 010 [def:0101] [use:0001] */          ZN=0x19;
/* 011 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 012 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x62CE);
/* 014 [def:0001] [use:0001] */      case 0x62D0: L_62d0: //F0 21 B0
/* 015 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x62D0);
/* 018 [def:0001] [use:0001] */              PC = 0x62f3;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62D0);
/* 002 [def:0001] [use:0001] */      case 0x62D2: L_62d2: //B0 34 20
/* 003 [def:0001] [use:2001] */          if (C)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x62D2);
/* 006 [def:0001] [use:0001] */              PC = 0x6308;
/*                           */              clockticks += 42;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62D2);
/* 002 [def:0001] [use:0001] */      case 0x62D4: L_62d4: //20 62 6F
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xD6;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62D4);
/* 006 [def:0001] [use:0001] */          PC = 0x6f62;
/*                           */          clockticks += 47; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x62D7: L_62d7: //B9 00 02
/* 001 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x62D7);
/* 004 [def:0001] [use:0001] */      case 0x62DA: L_62da: //29 03 49
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x62DA);
/* 008 [def:0001] [use:0001] */      case 0x62DC: L_62dc: //49 02 4A
/* 009 [def:0009] [use:0008] */          A ^= 0x02;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x62DC);
/* 012 [def:0001] [use:0001] */      case 0x62DE: L_62de: //4A 6A 6A
/* 013 [def:2001] [use:0008] */          C = A & 0x01;
/* 014 [def:0009] [use:0008] */          A = A >> 1;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x62DE);
/* 017 [def:0001] [use:0001] */      case 0x62DF: L_62df: //6A 6A 09
/* 018 [def:10001] [use:2000] */          saveflags = C;
/* 019 [def:2001] [use:0008] */          C = A & 0x01;
/* 020 [def:0009] [use:0008] */          A = A >> 1;
/* 021 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x62DF);
/* 024 [def:0001] [use:0001] */      case 0x62E0: L_62e0: //6A 09 3F
/* 025 [def:10001] [use:2000] */          saveflags = C;
/* 026 [def:2001] [use:0008] */          C = A & 0x01;
/* 027 [def:0009] [use:0008] */          A = A >> 1;
/* 028 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x62E0);
/* 031 [def:0001] [use:0001] */      case 0x62E1: L_62e1: //09 3F 85
/* 032 [def:0001] [use:0001] */          A |= 0x3F;
/* 033 [def:1800] [use:0008] */  //      ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x62E1);
/* 035 [def:0001] [use:0001] */      case 0x62E3: L_62e3: //85 7F A9
/* 036 [def:0001] [use:0008] */          ram[0x007F] = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x62E3);
/* 038 [def:0001] [use:0001] */      case 0x62E5: L_62e5: //A9 A0 99
/* 039 [def:0008] [use:0000] */  //      A=0xA0;
/* 040 [def:1800] [use:0008] */  //      ZN = A;
/* 041 [def:0001] [use:0001] */          //trace_PC(0x62E5);
/* 042 [def:0001] [use:0001] */      case 0x62E7: L_62e7: //99 00 02
/* 043 [def:0001] [use:0021] */          ram[(unsigned short)(0x0200 + Y)] = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x62E7);
/* 045 [def:0001] [use:0001] */      case 0x62EA: L_62ea: //A9 00 99
/* 046 [def:0009] [use:0000] */          A=0x00;
/* 047 [def:1801] [use:0008] */          ZN = A;
/* 048 [def:0001] [use:0001] */          //trace_PC(0x62EA);
/* 049 [def:0001] [use:0001] */      case 0x62EC: L_62ec: //99 21 02
/* 050 [def:0001] [use:0021] */          ram[(unsigned short)(0x0221 + Y)] = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x62EC);
/* 052 [def:0001] [use:0001] */      case 0x62EF: L_62ef: //99 42 02
/* 053 [def:0001] [use:0021] */          ram[(unsigned short)(0x0242 + Y)] = A;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x62EF);
/* 055 [def:0001] [use:0001] */      case 0x62F2: L_62f2: //60 20 F8
/* 056 [def:0001] [use:0001] */          //trace_PC(0x62F2);
/* 057 [def:0001] [use:0001] */          PC=stack[++S];
/* 058 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 059 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 48; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x62F3: L_62f3: //20 F8 62
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xF5;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x62F3);
/* 004 [def:0001] [use:0001] */          PC = 0x62f8;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x62F6: L_62f6: //D0 DF 8A
/* 001 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x62F6);
/* 004 [def:0001] [use:0001] */              PC = 0x62d7;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x62F6);
/* 002 [def:0001] [use:0001] */      case 0x62F8: L_62f8: //8A A6 1E
/* 003 [def:0001] [use:0001] */          A=X;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x62F8);
/* 006 [def:0001] [use:0001] */      case 0x62F9: L_62f9: //A6 1E D6
/* 007 [def:0001] [use:0001] */          X=ram[0x001E];
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x62F9);
/* 010 [def:0001] [use:0001] */      case 0x62FB: L_62fb: //D6 6F AA
/* 011 [def:0101] [use:0010] */          ZN=(0x006F + X)&0xFF;
/* 012 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 013 [def:1901] [use:0100] */          ZN--;
/* 014 [def:0001] [use:0101] */          ram[ZN] = ZN;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x62FB);
/* 016 [def:0001] [use:0001] */      case 0x62FD: L_62fd: //AA A9 81
/* 017 [def:0011] [use:0008] */          X=A;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x62FD);
/* 020 [def:0001] [use:0001] */      case 0x62FE: L_62fe: //A9 81 8D
/* 021 [def:0009] [use:0000] */          A=0x81;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x62FE);
/* 024 [def:0001] [use:0001] */      case 0x6300: L_6300: //8D EB 02
/* 025 [def:0001] [use:0008] */          ram[0x02EB] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6300);
/* 027 [def:0001] [use:0001] */      case 0x6303: L_6303: //A9 05 85
/* 028 [def:0009] [use:0000] */          A=0x05;
/* 029 [def:1801] [use:0008] */          ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6303);
/* 031 [def:0001] [use:0001] */      case 0x6305: L_6305: //85 DE 60
/* 032 [def:0001] [use:0008] */          ram[0x00DE] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6305);
/* 034 [def:0001] [use:0001] */      case 0x6307: L_6307: //60 AD E9
/* 035 [def:0001] [use:0001] */          //trace_PC(0x6307);
/* 036 [def:0001] [use:0001] */          PC=stack[++S];
/* 037 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 038 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 33; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6308: L_6308: //AD E9 02
/* 001 [def:0009] [use:0001] */          A=ram[0x02E9];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6308);
/* 004 [def:0001] [use:0001] */      case 0x630B: L_630b: //8D E8 02
/* 005 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x630B);
/* 007 [def:0001] [use:0001] */      case 0x630E: L_630e: //A5 22 F0
/* 008 [def:0009] [use:0001] */          A=ram[0x0022];
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x630E);
/* 011 [def:0001] [use:0001] */      case 0x6310: L_6310: //F0 C5 AD
/* 012 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6310);
/* 015 [def:0001] [use:0001] */              PC = 0x62d7;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6310);
/* 002 [def:0001] [use:0001] */      case 0x6312: L_6312: //AD 1A 02
/* 003 [def:0009] [use:0001] */          A=ram[0x021A];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6312);
/* 006 [def:0001] [use:0001] */      case 0x6315: L_6315: //4A A9 00
/* 007 [def:2001] [use:0008] */          C = A & 0x01;
/* 008 [def:0008] [use:0008] */  //      A = A >> 1;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6315);
/* 011 [def:0001] [use:0001] */      case 0x6316: L_6316: //A9 00 B0
/* 012 [def:0009] [use:0000] */          A=0x00;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6316);
/* 015 [def:0001] [use:0001] */      case 0x6318: L_6318: //B0 02 A9
/* 016 [def:0001] [use:2001] */          if (C)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x6318);
/* 019 [def:0001] [use:0001] */              PC = 0x631c;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6318);
/* 002 [def:0001] [use:0001] */      case 0x631A: L_631a: //A9 20 20
/* 003 [def:0009] [use:0000] */          A=0x20;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x631A);
/* 006 [def:0001] [use:0001] */      case 0x631C: L_631c: //20 44 6C
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x63;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x1E;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x631C);
/* 010 [def:0001] [use:0001] */          PC = 0x6c44;
/*                           */          clockticks += 33; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x631F: L_631f: //4C D7 62
/* 001 [def:0001] [use:0001] */          //trace_PC(0x631F);
/* 002 [def:0001] [use:0001] */          PC = 0x62d7;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6322: L_6322: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6322);
/* 004 [def:0001] [use:0001] */      case 0x6324: L_6324: //29 03 F0
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6324);
/* 008 [def:0001] [use:0001] */      case 0x6326: L_6326: //F0 01 60
/* 009 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6326);
/* 012 [def:0001] [use:0001] */              PC = 0x6329;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6326);
/* 002 [def:0001] [use:0001] */      case 0x6328: L_6328: //60 AD 1A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6328);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6329: L_6329: //AD 1A 02
/* 001 [def:0009] [use:0001] */          A=ram[0x021A];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6329);
/* 004 [def:0001] [use:0001] */      case 0x632C: L_632c: //F0 0A 10
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x632C);
/* 008 [def:0001] [use:0001] */              PC = 0x6338;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x632C);
/* 002 [def:0001] [use:0001] */      case 0x632E: L_632e: //10 05 A0
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x632E);
/* 006 [def:0001] [use:0001] */              PC = 0x6335;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x632E);
/* 002 [def:0001] [use:0001] */      case 0x6330: L_6330: //A0 17 4C
/* 003 [def:0021] [use:0000] */          Y=0x17;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6330);
/* 006 [def:0001] [use:0001] */      case 0x6332: L_6332: //4C 0D 77
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6332);
/* 008 [def:0001] [use:0001] */          PC = 0x770d;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6335: L_6335: //4C C5 63
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6335);
/* 002 [def:0001] [use:0001] */          PC = 0x63c5;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6338: L_6338: //20 FA 67
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x63;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x3A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6338);
/* 004 [def:0001] [use:0001] */          PC = 0x67fa;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x633B: L_633b: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x633B);
/* 004 [def:0001] [use:0001] */      case 0x633D: L_633d: //F0 07 AD
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x633D);
/* 008 [def:0001] [use:0001] */              PC = 0x6346;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x633D);
/* 002 [def:0001] [use:0001] */      case 0x633F: L_633f: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x633F);
/* 006 [def:0001] [use:0001] */      case 0x6342: L_6342: //F0 E4 30
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6342);
/* 010 [def:0001] [use:0001] */              PC = 0x6328;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6342);
/* 002 [def:0001] [use:0001] */      case 0x6344: L_6344: //30 E2 AD
/* 003 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6344);
/* 006 [def:0001] [use:0001] */              PC = 0x6328;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6344);
/* 002 [def:0001] [use:0001] */      case 0x6346: L_6346: //AD EA 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EA];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6346);
/* 006 [def:0001] [use:0001] */      case 0x6349: L_6349: //F0 03 CE
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6349);
/* 010 [def:0001] [use:0001] */              PC = 0x634e;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6349);
/* 002 [def:0001] [use:0001] */      case 0x634B: L_634b: //CE EA 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02EA];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x634B);
/* 005 [def:0001] [use:0001] */      case 0x634E: L_634e: //CE E8 02
/* 006 [def:1801] [use:0001] */          ZN=--ram[0x02E8];
/* 007 [def:0001] [use:0001] */          //trace_PC(0x634E);
/* 008 [def:0001] [use:0001] */      case 0x6351: L_6351: //D0 D5 A9
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6351);
/* 012 [def:0001] [use:0001] */              PC = 0x6328;
/*                           */              clockticks += 34;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6351);
/* 002 [def:0001] [use:0001] */      case 0x6353: L_6353: //A9 01 8D
/* 003 [def:0009] [use:0000] */          A=0x01;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6353);
/* 006 [def:0001] [use:0001] */      case 0x6355: L_6355: //8D E8 02
/* 007 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6355);
/* 009 [def:0001] [use:0001] */      case 0x6358: L_6358: //AE E7 02
/* 010 [def:0001] [use:0001] */          X=ram[0x02E7];
/* 011 [def:1801] [use:0010] */          ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6358);
/* 013 [def:0001] [use:0001] */      case 0x635B: L_635b: //F0 CB AD
/* 014 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x635B);
/* 017 [def:0001] [use:0001] */              PC = 0x6328;
/*                           */              clockticks += 47;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x635B);
/* 002 [def:0001] [use:0001] */      case 0x635D: L_635d: //AD EA 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EA];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x635D);
/* 006 [def:0001] [use:0001] */      case 0x6360: L_6360: //F0 05 EC
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6360);
/* 010 [def:0001] [use:0001] */              PC = 0x6367;
/*                           */              clockticks += 53;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6360);
/* 002 [def:0001] [use:0001] */      case 0x6362: L_6362: //EC EE 02
/* 003 [def:0101] [use:0001] */          ZN=ram[0x02EE];
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6362);
/* 007 [def:0001] [use:0001] */      case 0x6365: L_6365: //B0 C1 AD
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6365);
/* 011 [def:0001] [use:0001] */              PC = 0x6328;
/*                           */              clockticks += 59;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6365);
/* 002 [def:0001] [use:0001] */      case 0x6367: L_6367: //AD E9 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02E9];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6367);
/* 006 [def:0001] [use:0001] */      case 0x636A: L_636a: //38 E9 06
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x636A);
/* 009 [def:0001] [use:0001] */      case 0x636B: L_636b: //E9 06 C9
/* 010 [def:b809] [use:6009] */          SBC(0x06);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x636B);
/* 012 [def:0001] [use:0001] */      case 0x636D: L_636d: //C9 20 90
/* 013 [def:0101] [use:0000] */          ZN=0x20;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x636D);
/* 017 [def:0001] [use:0001] */      case 0x636F: L_636f: //90 03 8D
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x636F);
/* 021 [def:0001] [use:0001] */              PC = 0x6374;
/*                           */              clockticks += 73;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x636F);
/* 002 [def:0001] [use:0001] */      case 0x6371: L_6371: //8D E9 02
/* 003 [def:0001] [use:0008] */          ram[0x02E9] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6371);
/* 005 [def:0001] [use:0001] */      case 0x6374: L_6374: //AD 0A 2C
/* 006 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6374);
/* 009 [def:0001] [use:0001] */      case 0x6377: L_6377: //4A 6E E0
/* 010 [def:2001] [use:0008] */          C = A & 0x01;
/* 011 [def:0009] [use:0008] */          A = A >> 1;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6377);
/* 014 [def:0001] [use:0001] */      case 0x6378: L_6378: //6E E0 02
/* 015 [def:10001] [use:2000] */          saveflags = C;
/* 016 [def:0101] [use:0001] */          ZN=ram[0x02E0];
/* 017 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 018 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 019 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 020 [def:0001] [use:0101] */          ram[0x02E0] = ZN;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6378);
/* 022 [def:0001] [use:0001] */      case 0x637B: L_637b: //4A 6E E0
/* 023 [def:2001] [use:0008] */          C = A & 0x01;
/* 024 [def:0009] [use:0008] */          A = A >> 1;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x637B);
/* 027 [def:0001] [use:0001] */      case 0x637C: L_637c: //6E E0 02
/* 028 [def:10001] [use:2000] */          saveflags = C;
/* 029 [def:0101] [use:0001] */          ZN=ram[0x02E0];
/* 030 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 031 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 032 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 033 [def:0001] [use:0101] */          ram[0x02E0] = ZN;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x637C);
/* 035 [def:0001] [use:0001] */      case 0x637F: L_637f: //4A 6E E0
/* 036 [def:2001] [use:0008] */          C = A & 0x01;
/* 037 [def:0009] [use:0008] */          A = A >> 1;
/* 038 [def:1800] [use:0008] */  //      ZN = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x637F);
/* 040 [def:0001] [use:0001] */      case 0x6380: L_6380: //6E E0 02
/* 041 [def:10001] [use:2000] */          saveflags = C;
/* 042 [def:0101] [use:0001] */          ZN=ram[0x02E0];
/* 043 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 044 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 045 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 046 [def:0001] [use:0101] */          ram[0x02E0] = ZN;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6380);
/* 048 [def:0001] [use:0001] */      case 0x6383: L_6383: //69 04 C9
/* 049 [def:b801] [use:6001] */          ADC(0x04);
/* 050 [def:0001] [use:0001] */          //trace_PC(0x6383);
/* 051 [def:0001] [use:0001] */      case 0x6385: L_6385: //C9 12 90
/* 052 [def:0101] [use:0000] */          ZN=0x12;
/* 053 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 054 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 055 [def:0001] [use:0001] */          //trace_PC(0x6385);
/* 056 [def:0001] [use:0001] */      case 0x6387: L_6387: //90 02 E9
/* 057 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 058 [def:0001] [use:0001] */          {
/* 059 [def:0001] [use:0001] */              //trace_PC(0x6387);
/* 060 [def:0001] [use:0001] */              PC = 0x638b;
/*                           */              clockticks += 113;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6387);
/* 002 [def:0001] [use:0001] */      case 0x6389: L_6389: //E9 10 8D
/* 003 [def:b809] [use:6009] */          SBC(0x10);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6389);
/* 005 [def:0001] [use:0001] */      case 0x638B: L_638b: //8D 9E 02
/* 006 [def:0001] [use:0008] */          ram[0x029E] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x638B);
/* 008 [def:0001] [use:0001] */      case 0x638E: L_638e: //AD 0A 2C
/* 009 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x638E);
/* 012 [def:0001] [use:0001] */      case 0x6391: L_6391: //0A A9 00
/* 013 [def:2001] [use:0008] */          C = A & 0x80;
/* 014 [def:0008] [use:0008] */  //      A = A << 1;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6391);
/* 017 [def:0001] [use:0001] */      case 0x6392: L_6392: //A9 00 AA
/* 018 [def:0009] [use:0000] */          A=0x00;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6392);
/* 021 [def:0001] [use:0001] */      case 0x6394: L_6394: //AA A0 10
/* 022 [def:0011] [use:0008] */          X=A;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6394);
/* 025 [def:0001] [use:0001] */      case 0x6395: L_6395: //A0 10 90
/* 026 [def:0021] [use:0000] */          Y=0x10;
/* 027 [def:1801] [use:0020] */          ZN = Y;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6395);
/* 029 [def:0001] [use:0001] */      case 0x6397: L_6397: //90 05 CA
/* 030 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 031 [def:0001] [use:0001] */          {
/* 032 [def:0001] [use:0001] */              //trace_PC(0x6397);
/* 033 [def:0001] [use:0001] */              PC = 0x639e;
/*                           */              clockticks += 136;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6397);
/* 002 [def:0001] [use:0001] */      case 0x6399: L_6399: //CA A9 1F
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6399);
/* 006 [def:0001] [use:0001] */      case 0x639A: L_639a: //A9 1F A0
/* 007 [def:0009] [use:0000] */          A=0x1F;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x639A);
/* 010 [def:0001] [use:0001] */      case 0x639C: L_639c: //A0 F0 8C
/* 011 [def:0020] [use:0000] */  //      Y=0xF0;
/* 012 [def:1800] [use:0020] */  //      ZN = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x639C);
/* 014 [def:0001] [use:0001] */      case 0x639E: L_639e: //8C 3B 02
/* 015 [def:0001] [use:0001] */          ram[0x023B] = Y;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x639E);
/* 017 [def:0001] [use:0001] */      case 0x63A1: L_63a1: //8D 7D 02
/* 018 [def:0001] [use:0008] */          ram[0x027D] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x63A1);
/* 020 [def:0001] [use:0001] */      case 0x63A4: L_63a4: //8E BF 02
/* 021 [def:0001] [use:0001] */          ram[0x02BF] = X;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x63A4);
/* 023 [def:0001] [use:0001] */      case 0x63A7: L_63a7: //A0 02 A5
/* 024 [def:0021] [use:0000] */          Y=0x02;
/* 025 [def:1800] [use:0020] */  //      ZN = Y;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x63A7);
/* 027 [def:0001] [use:0001] */      case 0x63A9: L_63a9: //A5 D3 F0
/* 028 [def:0009] [use:0001] */          A=ram[0x00D3];
/* 029 [def:1801] [use:0008] */          ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x63A9);
/* 031 [def:0001] [use:0001] */      case 0x63AB: L_63ab: //F0 0C AD
/* 032 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 033 [def:0001] [use:0001] */          {
/* 034 [def:0001] [use:0001] */              //trace_PC(0x63AB);
/* 035 [def:0001] [use:0001] */              PC = 0x63b9;
/*                           */              clockticks += 164;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63AB);
/* 002 [def:0001] [use:0001] */      case 0x63AD: L_63ad: //AD EE 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EE];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63AD);
/* 006 [def:0001] [use:0001] */      case 0x63B0: L_63b0: //38 ED E7
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x63B0);
/* 009 [def:0001] [use:0001] */      case 0x63B1: L_63b1: //ED E7 02
/* 010 [def:b809] [use:6009] */          SBC(ram[0x02E7]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x63B1);
/* 012 [def:0001] [use:0001] */      case 0x63B4: L_63b4: //C9 04 90
/* 013 [def:0101] [use:0000] */          ZN=0x04;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x63B4);
/* 017 [def:0001] [use:0001] */      case 0x63B6: L_63b6: //90 01 88
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x63B6);
/* 021 [def:0001] [use:0001] */              PC = 0x63b9;
/*                           */              clockticks += 179;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63B6);
/* 002 [def:0001] [use:0001] */      case 0x63B8: L_63b8: //88 8C 1A
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63B8);
/* 006 [def:0001] [use:0001] */      case 0x63B9: L_63b9: //8C 1A 02
/* 007 [def:0001] [use:0001] */          ram[0x021A] = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x63B9);
/* 009 [def:0001] [use:0001] */      case 0x63BC: L_63bc: //B9 C2 63
/* 010 [def:0009] [use:0021] */          A=ram[0x63C2 + Y /* can't wrap */];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x63BC);
/* 013 [def:0001] [use:0001] */      case 0x63BF: L_63bf: //A8 4C 16
/* 014 [def:0021] [use:0008] */          Y=A;
/* 015 [def:1801] [use:0008] */          ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x63BF);
/* 017 [def:0001] [use:0001] */      case 0x63C0: L_63c0: //4C 16 77
/* 018 [def:0001] [use:0001] */          //trace_PC(0x63C0);
/* 019 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 193; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x63C5: L_63c5: //A5 76 0A
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x63C5);
/* 004 [def:0001] [use:0001] */      case 0x63C7: L_63c7: //0A D0 0C
/* 005 [def:2001] [use:0008] */          C = A & 0x80;
/* 006 [def:0009] [use:0008] */          A = A << 1;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x63C7);
/* 009 [def:0001] [use:0001] */      case 0x63C8: L_63c8: //D0 0C AD
/* 010 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x63C8);
/* 013 [def:0001] [use:0001] */              PC = 0x63d6;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63C8);
/* 002 [def:0001] [use:0001] */      case 0x63CA: L_63ca: //AD 0A 2C
/* 003 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63CA);
/* 006 [def:0001] [use:0001] */      case 0x63CD: L_63cd: //29 03 AA
/* 007 [def:0009] [use:0008] */          A &= 0x03;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x63CD);
/* 010 [def:0001] [use:0001] */      case 0x63CF: L_63cf: //AA BD 57
/* 011 [def:0011] [use:0008] */          X=A;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x63CF);
/* 014 [def:0001] [use:0001] */      case 0x63D0: L_63d0: //BD 57 64
/* 015 [def:0009] [use:0011] */          A=ram[0x6457 + X /* can't wrap */];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x63D0);
/* 018 [def:0001] [use:0001] */      case 0x63D3: L_63d3: //8D 5C 02
/* 019 [def:0001] [use:0008] */          ram[0x025C] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x63D3);
/* 021 [def:0001] [use:0001] */      case 0x63D6: L_63d6: //A5 22 F0
/* 022 [def:0009] [use:0001] */          A=ram[0x0022];
/* 023 [def:1801] [use:0008] */          ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x63D6);
/* 025 [def:0001] [use:0001] */      case 0x63D8: L_63d8: //F0 05 AD
/* 026 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x63D8);
/* 029 [def:0001] [use:0001] */              PC = 0x63df;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63D8);
/* 002 [def:0001] [use:0001] */      case 0x63DA: L_63da: //AD EB 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EB];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63DA);
/* 006 [def:0001] [use:0001] */      case 0x63DD: L_63dd: //D0 05 CE
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x63DD);
/* 010 [def:0001] [use:0001] */              PC = 0x63e4;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63DD);
/* 002 [def:0001] [use:0001] */      case 0x63DF: L_63df: //CE E8 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02E8];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x63DF);
/* 005 [def:0001] [use:0001] */      case 0x63E2: L_63e2: //F0 01 60
/* 006 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x63E2);
/* 009 [def:0001] [use:0001] */              PC = 0x63e5;
/*                           */              clockticks += 44;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63E2);
/* 002 [def:0001] [use:0001] */      case 0x63E4: L_63e4: //60 A9 0A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x63E4);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 49; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x63E5: L_63e5: //A9 0A 8D
/* 001 [def:0009] [use:0000] */          A=0x0A;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x63E5);
/* 004 [def:0001] [use:0001] */      case 0x63E7: L_63e7: //8D E8 02
/* 005 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x63E7);
/* 007 [def:0001] [use:0001] */      case 0x63EA: L_63ea: //A0 19 A5
/* 008 [def:0021] [use:0000] */          Y=0x19;
/* 009 [def:1800] [use:0020] */  //      ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x63EA);
/* 011 [def:0001] [use:0001] */      case 0x63EC: L_63ec: //A5 22 F0
/* 012 [def:0009] [use:0001] */          A=ram[0x0022];
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x63EC);
/* 015 [def:0001] [use:0001] */      case 0x63EE: L_63ee: //F0 0F A2
/* 016 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x63EE);
/* 019 [def:0001] [use:0001] */              PC = 0x63ff;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63EE);
/* 002 [def:0001] [use:0001] */      case 0x63F0: L_63f0: //A2 AA AD
/* 003 [def:0001] [use:0001] */          X=0xAA;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63F0);
/* 006 [def:0001] [use:0001] */      case 0x63F2: L_63f2: //AD 1A 02
/* 007 [def:0009] [use:0001] */          A=ram[0x021A];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x63F2);
/* 010 [def:0001] [use:0001] */      case 0x63F5: L_63f5: //4A B0 02
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x63F5);
/* 015 [def:0001] [use:0001] */      case 0x63F6: L_63f6: //B0 02 A2
/* 016 [def:0001] [use:2001] */          if (C)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x63F6);
/* 019 [def:0001] [use:0001] */              PC = 0x63fa;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63F6);
/* 002 [def:0001] [use:0001] */      case 0x63F8: L_63f8: //A2 40 EC
/* 003 [def:0001] [use:0001] */          X=0x40;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63F8);
/* 006 [def:0001] [use:0001] */      case 0x63FA: L_63fa: //EC 0A 2C
/* 007 [def:0101] [use:0001] */          ZN=ram[0x2C0A];
/* 008 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 009 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x63FA);
/* 011 [def:0001] [use:0001] */      case 0x63FD: L_63fd: //B0 03 20
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x63FD);
/* 015 [def:0001] [use:0001] */              PC = 0x6402;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x63FD);
/* 002 [def:0001] [use:0001] */      case 0x63FF: L_63ff: //20 5B 64
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x01;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x63FF);
/* 006 [def:0001] [use:0001] */          PC = 0x645b;
/*                           */          clockticks += 41; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6402: L_6402: //84 18 A2
/* 001 [def:0001] [use:0020] */          ram[0x0018] = Y;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6402);
/* 003 [def:0001] [use:0001] */      case 0x6404: L_6404: //A2 1A 20
/* 004 [def:0001] [use:0001] */          X=0x1A;
/* 005 [def:1801] [use:0010] */          ZN = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6404);
/* 007 [def:0001] [use:0001] */      case 0x6406: L_6406: //20 22 4A
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x08;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6406);
/* 011 [def:0001] [use:0001] */          PC = 0x4a22;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6409: L_6409: //20 E7 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x0B;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6409);
/* 004 [def:0001] [use:0001] */          PC = 0x49e7;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x640C: L_640c: //85 13 A5
/* 001 [def:0001] [use:0008] */          ram[0x0013] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x640C);
/* 003 [def:0001] [use:0001] */      case 0x640E: L_640e: //A5 0C 85
/* 004 [def:0009] [use:0001] */          A=ram[0x000C];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x640E);
/* 007 [def:0001] [use:0001] */      case 0x6410: L_6410: //85 12 A5
/* 008 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6410);
/* 010 [def:0001] [use:0001] */      case 0x6412: L_6412: //A5 18 18
/* 011 [def:0009] [use:0001] */          A=ram[0x0018];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6412);
/* 014 [def:0001] [use:0001] */      case 0x6414: L_6414: //18 69 21
/* 015 [def:2001] [use:0000] */          C = 0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6414);
/* 017 [def:0001] [use:0001] */      case 0x6415: L_6415: //69 21 A8
/* 018 [def:b801] [use:6001] */          ADC(0x21);
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6415);
/* 020 [def:0001] [use:0001] */      case 0x6417: L_6417: //A8 A2 3B
/* 021 [def:0021] [use:0008] */          Y=A;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6417);
/* 024 [def:0001] [use:0001] */      case 0x6418: L_6418: //A2 3B 20
/* 025 [def:0001] [use:0001] */          X=0x3B;
/* 026 [def:1801] [use:0010] */          ZN = X;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6418);
/* 028 [def:0001] [use:0001] */      case 0x641A: L_641a: //20 22 4A
/* 029 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 030 [def:0001] [use:0001] */          stack[S--] = 0x1C;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x641A);
/* 032 [def:0001] [use:0001] */          PC = 0x4a22;
/*                           */          clockticks += 26; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x641D: L_641d: //20 E7 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x1F;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x641D);
/* 004 [def:0001] [use:0001] */          PC = 0x49e7;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6420: L_6420: //20 32 4A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x22;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6420);
/* 004 [def:0001] [use:0001] */          PC = 0x4a32;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6423: L_6423: //85 7A A5
/* 001 [def:0001] [use:0008] */          ram[0x007A] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6423);
/* 003 [def:0001] [use:0001] */      case 0x6425: L_6425: //A5 18 C9
/* 004 [def:0009] [use:0001] */          A=ram[0x0018];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6425);
/* 007 [def:0001] [use:0001] */      case 0x6427: L_6427: //C9 19 D0
/* 008 [def:0101] [use:0000] */          ZN=0x19;
/* 009 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 010 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6427);
/* 012 [def:0001] [use:0001] */      case 0x6429: L_6429: //D0 17 A6
/* 013 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x6429);
/* 016 [def:0001] [use:0001] */              PC = 0x6442;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6429);
/* 002 [def:0001] [use:0001] */      case 0x642B: L_642b: //A6 D3 E0
/* 003 [def:0001] [use:0001] */          X=ram[0x00D3];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x642B);
/* 006 [def:0001] [use:0001] */      case 0x642D: L_642d: //E0 03 90
/* 007 [def:0101] [use:0000] */          ZN=0x03;
/* 008 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 009 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x642D);
/* 011 [def:0001] [use:0001] */      case 0x642F: L_642f: //90 02 A2
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x642F);
/* 015 [def:0001] [use:0001] */              PC = 0x6433;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x642F);
/* 002 [def:0001] [use:0001] */      case 0x6433: L_6433: //AD 0A 2C
/* 003 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6433);
/* 006 [def:0001] [use:0001] */      case 0x6436: L_6436: //3D 4F 64
/* 007 [def:0001] [use:0011] */          A &= ram[(unsigned short)(0x644F + X)];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6436);
/* 010 [def:0001] [use:0001] */      case 0x6439: L_6439: //10 03 1D
/* 011 [def:0001] [use:1001] */          if (ZN < 0)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6439);
/* 014 [def:0001] [use:0001] */              PC = 0x643e;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6439);
/* 002 [def:0001] [use:0001] */      case 0x643B: L_643b: //1D 53 64
/* 003 [def:0001] [use:0011] */          A |= ram[(unsigned short)(0x6453 + X)];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x643B);
/* 006 [def:0001] [use:0001] */      case 0x643E: L_643e: //65 7A 85
/* 007 [def:b801] [use:6001] */          ADC(ram[0x007A]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x643E);
/* 009 [def:0001] [use:0001] */      case 0x6440: L_6440: //85 7A A0
/* 010 [def:0001] [use:0008] */          ram[0x007A] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6440);
/* 012 [def:0001] [use:0001] */      case 0x6442: L_6442: //A0 03 A9
/* 013 [def:0021] [use:0000] */          Y=0x03;
/* 014 [def:1800] [use:0020] */  //      ZN = Y;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6442);
/* 016 [def:0001] [use:0001] */      case 0x6444: L_6444: //A9 01 85
/* 017 [def:0009] [use:0000] */          A=0x01;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6444);
/* 020 [def:0001] [use:0001] */      case 0x6446: L_6446: //85 0F A6
/* 021 [def:0001] [use:0008] */          ram[0x000F] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6446);
/* 023 [def:0001] [use:0001] */      case 0x6448: L_6448: //A6 18 85
/* 024 [def:0001] [use:0001] */          X=ram[0x0018];
/* 025 [def:1801] [use:0010] */          ZN = X;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6448);
/* 027 [def:0001] [use:0001] */      case 0x644A: L_644a: //85 18 4C
/* 028 [def:0001] [use:0008] */          ram[0x0018] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x644A);
/* 030 [def:0001] [use:0001] */      case 0x644C: L_644c: //4C C8 64
/* 031 [def:0001] [use:0001] */          //trace_PC(0x644C);
/* 032 [def:0001] [use:0001] */          PC = 0x64c8;
/*                           */          clockticks += 53; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x645B: L_645b: //88 B9 00
/* 001 [def:0021] [use:0020] */          Y--;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x645B);
/* 004 [def:0001] [use:0001] */      case 0x645C: L_645c: //B9 00 02
/* 005 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x645C);
/* 008 [def:0001] [use:0001] */      case 0x645F: L_645f: //D0 07 88
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x645F);
/* 012 [def:0001] [use:0001] */              PC = 0x6468;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x645F);
/* 002 [def:0001] [use:0001] */      case 0x6461: L_6461: //88 10 F8
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6461);
/* 006 [def:0001] [use:0001] */      case 0x6462: L_6462: //10 F8 A0
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6462);
/* 010 [def:0001] [use:0001] */              PC = 0x645c;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6462);
/* 002 [def:0001] [use:0001] */      case 0x6464: L_6464: //A0 19 38
/* 003 [def:0021] [use:0000] */          Y=0x19;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6464);
/* 006 [def:0001] [use:0001] */      case 0x6466: L_6466: //38 60 30
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6466);
/* 009 [def:0001] [use:0001] */      case 0x6467: L_6467: //60 30 F7
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6467);
/* 011 [def:0001] [use:0001] */          PC=stack[++S];
/* 012 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 013 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 23; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6468: L_6468: //30 F7 C9
/* 001 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6468);
/* 004 [def:0001] [use:0001] */              PC = 0x6461;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6468);
/* 002 [def:0001] [use:0001] */      case 0x646A: L_646a: //C9 40 90
/* 003 [def:0101] [use:0000] */          ZN=0x40;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x646A);
/* 007 [def:0001] [use:0001] */      case 0x646C: L_646c: //90 0A 4A
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x646C);
/* 011 [def:0001] [use:0001] */              PC = 0x6478;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x646C);
/* 002 [def:0001] [use:0001] */      case 0x646E: L_646e: //4A 4A AA
/* 003 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 004 [def:0009] [use:0008] */          A = A >> 1;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x646E);
/* 007 [def:0001] [use:0001] */      case 0x646F: L_646f: //4A AA BD
/* 008 [def:2001] [use:0008] */          C = A & 0x01;
/* 009 [def:0009] [use:0008] */          A = A >> 1;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x646F);
/* 012 [def:0001] [use:0001] */      case 0x6470: L_6470: //AA BD E8
/* 013 [def:0011] [use:0008] */          X=A;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6470);
/* 016 [def:0001] [use:0001] */      case 0x6471: L_6471: //BD E8 02
/* 017 [def:0009] [use:0011] */          A=ram[0x02E8 + X /* can't wrap */];
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6471);
/* 020 [def:0001] [use:0001] */      case 0x6474: L_6474: //10 EB 18
/* 021 [def:0001] [use:1001] */          if (ZN < 0)
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x6474);
/* 024 [def:0001] [use:0001] */              PC = 0x6461;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6474);
/* 002 [def:0001] [use:0001] */      case 0x6476: L_6476: //18 60 AD
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6476);
/* 005 [def:0001] [use:0001] */      case 0x6477: L_6477: //60 AD 7D
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6477);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6478: L_6478: //AD 7D 02
/* 001 [def:0009] [use:0001] */          A=ram[0x027D];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6478);
/* 004 [def:0001] [use:0001] */      case 0x647B: L_647b: //38 F9 63
/* 005 [def:2001] [use:0000] */          C = 1;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x647B);
/* 007 [def:0001] [use:0001] */      case 0x647C: L_647c: //F9 63 02
/* 008 [def:b801] [use:6021] */          SBC(ram[(unsigned short)(0x0263 + Y)]);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x647C);
/* 010 [def:0001] [use:0001] */      case 0x647F: L_647f: //10 02 49
/* 011 [def:0001] [use:1001] */          if (ZN < 0)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x647F);
/* 014 [def:0001] [use:0001] */              PC = 0x6483;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x647F);
/* 002 [def:0001] [use:0001] */      case 0x6481: L_6481: //49 FF C9
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6481);
/* 006 [def:0001] [use:0001] */      case 0x6483: L_6483: //C9 08 B0
/* 007 [def:0101] [use:0000] */          ZN=0x08;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6483);
/* 011 [def:0001] [use:0001] */      case 0x6485: L_6485: //B0 DA AD
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6485);
/* 015 [def:0001] [use:0001] */              PC = 0x6461;
/*                           */              clockticks += 21;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6485);
/* 002 [def:0001] [use:0001] */      case 0x6487: L_6487: //AD 9E 02
/* 003 [def:0009] [use:0001] */          A=ram[0x029E];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6487);
/* 006 [def:0001] [use:0001] */      case 0x648A: L_648a: //38 F9 84
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x648A);
/* 009 [def:0001] [use:0001] */      case 0x648B: L_648b: //F9 84 02
/* 010 [def:b801] [use:6021] */          SBC(ram[(unsigned short)(0x0284 + Y)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x648B);
/* 012 [def:0001] [use:0001] */      case 0x648E: L_648e: //10 02 49
/* 013 [def:0001] [use:1001] */          if (ZN < 0)
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x648E);
/* 016 [def:0001] [use:0001] */              PC = 0x6492;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x648E);
/* 002 [def:0001] [use:0001] */      case 0x6490: L_6490: //49 FF C9
/* 003 [def:0009] [use:0008] */          A ^= 0xFF;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6490);
/* 006 [def:0001] [use:0001] */      case 0x6492: L_6492: //C9 08 B0
/* 007 [def:0101] [use:0000] */          ZN=0x08;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6492);
/* 011 [def:0001] [use:0001] */      case 0x6494: L_6494: //B0 CB 60
/* 012 [def:0001] [use:2001] */          if (C)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6494);
/* 015 [def:0001] [use:0001] */              PC = 0x6461;
/*                           */              clockticks += 41;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6494);
/* 002 [def:0001] [use:0001] */      case 0x6496: L_6496: //60 A2 00
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6496);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 46; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6497: L_6497: //A2 00 A5
/* 001 [def:0001] [use:0001] */          X=0x00;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6497);
/* 004 [def:0001] [use:0001] */      case 0x6499: L_6499: //A5 22 D0
/* 005 [def:0009] [use:0001] */          A=ram[0x0022];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6499);
/* 008 [def:0001] [use:0001] */      case 0x649B: L_649b: //D0 03 86
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x649B);
/* 012 [def:0001] [use:0001] */              PC = 0x64a0;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x649B);
/* 002 [def:0001] [use:0001] */      case 0x649D: L_649d: //86 FF 60
/* 003 [def:0001] [use:0001] */          ram[0x00FF] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x649D);
/* 005 [def:0001] [use:0001] */      case 0x649F: L_649f: //60 24 73
/* 006 [def:0001] [use:0001] */          //trace_PC(0x649F);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 16; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x64A0: L_64a0: //24 73 30
/* 001 [def:1101] [use:0001] */          ZN=ram[0x0073];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x64A0);
/* 005 [def:0001] [use:0001] */      case 0x64A2: L_64a2: //30 F9 24
/* 006 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x64A2);
/* 009 [def:0001] [use:0001] */              PC = 0x649d;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64A2);
/* 002 [def:0001] [use:0001] */      case 0x64A4: L_64a4: //24 FE 10
/* 003 [def:1101] [use:0001] */          ZN=ram[0x00FE];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 004 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 005 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64A4);
/* 007 [def:0001] [use:0001] */      case 0x64A6: L_64a6: //10 F5 AD
/* 008 [def:0001] [use:1001] */          if (ZN < 0)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x64A6);
/* 011 [def:0001] [use:0001] */              PC = 0x649d;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64A6);
/* 002 [def:0001] [use:0001] */      case 0x64A8: L_64a8: //AD EB 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EB];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x64A8);
/* 006 [def:0001] [use:0001] */      case 0x64AB: L_64ab: //D0 F0 E6
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x64AB);
/* 010 [def:0001] [use:0001] */              PC = 0x649d;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64AB);
/* 002 [def:0001] [use:0001] */      case 0x64AD: L_64ad: //E6 FF A5
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x00FF];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x64AD);
/* 005 [def:0001] [use:0001] */      case 0x64AF: L_64af: //A5 FF C9
/* 006 [def:0009] [use:0001] */          A=ram[0x00FF];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x64AF);
/* 009 [def:0001] [use:0001] */      case 0x64B1: L_64b1: //C9 02 90
/* 010 [def:0101] [use:0000] */          ZN=0x02;
/* 011 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 012 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x64B1);
/* 014 [def:0001] [use:0001] */      case 0x64B3: L_64b3: //90 05 C9
/* 015 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x64B3);
/* 018 [def:0001] [use:0001] */              PC = 0x64ba;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64B3);
/* 002 [def:0001] [use:0001] */      case 0x64B5: L_64b5: //C9 0F B0
/* 003 [def:0101] [use:0000] */          ZN=0x0F;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64B5);
/* 007 [def:0001] [use:0001] */      case 0x64B7: L_64b7: //B0 E4 60
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x64B7);
/* 011 [def:0001] [use:0001] */              PC = 0x649d;
/*                           */              clockticks += 35;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64B7);
/* 002 [def:0001] [use:0001] */      case 0x64B9: L_64b9: //60 86 18
/* 003 [def:0001] [use:0001] */          //trace_PC(0x64B9);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 40; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x64BA: L_64ba: //86 18 A9
/* 001 [def:0001] [use:0001] */          ram[0x0018] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x64BA);
/* 003 [def:0001] [use:0001] */      case 0x64BC: L_64bc: //A9 03 85
/* 004 [def:0009] [use:0000] */          A=0x03;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64BC);
/* 007 [def:0001] [use:0001] */      case 0x64BE: L_64be: //85 0F A2
/* 008 [def:0001] [use:0008] */          ram[0x000F] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x64BE);
/* 010 [def:0001] [use:0001] */      case 0x64C0: L_64c0: //A2 19 A5
/* 011 [def:0001] [use:0001] */          X=0x19;
/* 012 [def:1800] [use:0010] */  //      ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x64C0);
/* 014 [def:0001] [use:0001] */      case 0x64C2: L_64c2: //A5 79 85
/* 015 [def:0009] [use:0001] */          A=ram[0x0079];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x64C2);
/* 018 [def:0001] [use:0001] */      case 0x64C4: L_64c4: //85 7A A0
/* 019 [def:0001] [use:0008] */          ram[0x007A] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x64C4);
/* 021 [def:0001] [use:0001] */      case 0x64C6: L_64c6: //A0 07 B9
/* 022 [def:0021] [use:0000] */          Y=0x07;
/* 023 [def:1800] [use:0020] */  //      ZN = Y;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x64C6);
/* 025 [def:0001] [use:0001] */      case 0x64C8: L_64c8: //B9 19 02
/* 026 [def:0009] [use:0021] */          A=ram[0x0219 + Y /* can't wrap */];
/* 027 [def:1801] [use:0008] */          ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x64C8);
/* 029 [def:0001] [use:0001] */      case 0x64CB: L_64cb: //F0 06 88
/* 030 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 031 [def:0001] [use:0001] */          {
/* 032 [def:0001] [use:0001] */              //trace_PC(0x64CB);
/* 033 [def:0001] [use:0001] */              PC = 0x64d3;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64CB);
/* 002 [def:0001] [use:0001] */      case 0x64CD: L_64cd: //88 C4 0F
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x64CD);
/* 006 [def:0001] [use:0001] */      case 0x64CE: L_64ce: //C4 0F D0
/* 007 [def:0001] [use:0001] */          ZN=ram[0x000F];
/* 008 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 009 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x64CE);
/* 011 [def:0001] [use:0001] */      case 0x64D0: L_64d0: //D0 F6 60
/* 012 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x64D0);
/* 015 [def:0001] [use:0001] */              PC = 0x64c8;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64D0);
/* 002 [def:0001] [use:0001] */      case 0x64D2: L_64d2: //60 86 0E
/* 003 [def:0001] [use:0001] */          //trace_PC(0x64D2);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 37; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x64D3: L_64d3: //86 0E A9
/* 001 [def:0001] [use:0001] */          ram[0x000E] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x64D3);
/* 003 [def:0001] [use:0001] */      case 0x64D5: L_64d5: //A9 12 99
/* 004 [def:0008] [use:0000] */  //      A=0x12;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64D5);
/* 007 [def:0001] [use:0001] */      case 0x64D7: L_64d7: //99 19 02
/* 008 [def:0001] [use:0021] */          ram[(unsigned short)(0x0219 + Y)] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x64D7);
/* 010 [def:0001] [use:0001] */      case 0x64DA: L_64da: //A5 7A 20
/* 011 [def:0009] [use:0001] */          A=ram[0x007A];
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x64DA);
/* 014 [def:0001] [use:0001] */      case 0x64DC: L_64dc: //20 FE 70
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0xDE;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x64DC);
/* 018 [def:0001] [use:0001] */          PC = 0x70fe;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x64DF: L_64df: //A6 0E C9
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x64DF);
/* 004 [def:0001] [use:0001] */      case 0x64E1: L_64e1: //C9 80 6A
/* 005 [def:0101] [use:0000] */          ZN=0x80;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x64E1);
/* 009 [def:0001] [use:0001] */      case 0x64E3: L_64e3: //6A 85 0A
/* 010 [def:10001] [use:2000] */          saveflags = C;
/* 011 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x64E3);
/* 016 [def:0001] [use:0001] */      case 0x64E4: L_64e4: //85 0A 18
/* 017 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x64E4);
/* 019 [def:0001] [use:0001] */      case 0x64E6: L_64e6: //18 7D 21
/* 020 [def:2001] [use:0000] */          C = 0;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x64E6);
/* 022 [def:0001] [use:0001] */      case 0x64E7: L_64e7: //7D 21 02
/* 023 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0221 + X)]);
/* 024 [def:0001] [use:0001] */          //trace_PC(0x64E7);
/* 025 [def:0001] [use:0001] */      case 0x64EA: L_64ea: //30 08 C9
/* 026 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x64EA);
/* 029 [def:0001] [use:0001] */              PC = 0x64f4;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64EA);
/* 002 [def:0001] [use:0001] */      case 0x64EC: L_64ec: //C9 70 90
/* 003 [def:0101] [use:0000] */          ZN=0x70;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64EC);
/* 007 [def:0001] [use:0001] */      case 0x64EE: L_64ee: //90 0A A9
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x64EE);
/* 011 [def:0001] [use:0001] */              PC = 0x64fa;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64EE);
/* 002 [def:0001] [use:0001] */      case 0x64F4: L_64f4: //C9 91 B0
/* 003 [def:0101] [use:0000] */          ZN=0x91;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x64F4);
/* 007 [def:0001] [use:0001] */      case 0x64F6: L_64f6: //B0 02 A9
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x64F6);
/* 011 [def:0001] [use:0001] */              PC = 0x64fa;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x64F6);
/* 002 [def:0001] [use:0001] */      case 0x64FA: L_64fa: //99 3A 02
/* 003 [def:0001] [use:0021] */          ram[(unsigned short)(0x023A + Y)] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x64FA);
/* 005 [def:0001] [use:0001] */      case 0x64FD: L_64fd: //A5 7A 20
/* 006 [def:0009] [use:0001] */          A=ram[0x007A];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x64FD);
/* 009 [def:0001] [use:0001] */      case 0x64FF: L_64ff: //20 01 71
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x01;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x64FF);
/* 013 [def:0001] [use:0001] */          PC = 0x7101;
/*                           */          clockticks += 42; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6502: L_6502: //A6 0E C9
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6502);
/* 004 [def:0001] [use:0001] */      case 0x6504: L_6504: //C9 80 6A
/* 005 [def:0101] [use:0000] */          ZN=0x80;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6504);
/* 009 [def:0001] [use:0001] */      case 0x6506: L_6506: //6A 85 0D
/* 010 [def:10001] [use:2000] */          saveflags = C;
/* 011 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6506);
/* 016 [def:0001] [use:0001] */      case 0x6507: L_6507: //85 0D 18
/* 017 [def:0001] [use:0008] */          ram[0x000D] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6507);
/* 019 [def:0001] [use:0001] */      case 0x6509: L_6509: //18 7D 42
/* 020 [def:2001] [use:0000] */          C = 0;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6509);
/* 022 [def:0001] [use:0001] */      case 0x650A: L_650a: //7D 42 02
/* 023 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0242 + X)]);
/* 024 [def:0001] [use:0001] */          //trace_PC(0x650A);
/* 025 [def:0001] [use:0001] */      case 0x650D: L_650d: //30 08 C9
/* 026 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x650D);
/* 029 [def:0001] [use:0001] */              PC = 0x6517;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x650D);
/* 002 [def:0001] [use:0001] */      case 0x650F: L_650f: //C9 70 90
/* 003 [def:0101] [use:0000] */          ZN=0x70;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x650F);
/* 007 [def:0001] [use:0001] */      case 0x6511: L_6511: //90 0A A9
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6511);
/* 011 [def:0001] [use:0001] */              PC = 0x651d;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6511);
/* 002 [def:0001] [use:0001] */      case 0x6517: L_6517: //C9 91 B0
/* 003 [def:0101] [use:0000] */          ZN=0x91;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6517);
/* 007 [def:0001] [use:0001] */      case 0x6519: L_6519: //B0 02 A9
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6519);
/* 011 [def:0001] [use:0001] */              PC = 0x651d;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6519);
/* 002 [def:0001] [use:0001] */      case 0x651D: L_651d: //99 5B 02
/* 003 [def:0001] [use:0021] */          ram[(unsigned short)(0x025B + Y)] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x651D);
/* 005 [def:0001] [use:0001] */      case 0x6520: L_6520: //A2 00 A5
/* 006 [def:0001] [use:0001] */          X=0x00;
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6520);
/* 009 [def:0001] [use:0001] */      case 0x6522: L_6522: //A5 0A 10
/* 010 [def:0009] [use:0001] */          A=ram[0x000A];
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6522);
/* 013 [def:0001] [use:0001] */      case 0x6524: L_6524: //10 01 CA
/* 014 [def:0001] [use:1001] */          if (ZN < 0)
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6524);
/* 017 [def:0001] [use:0001] */              PC = 0x6527;
/*                           */              clockticks += 42;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6524);
/* 002 [def:0001] [use:0001] */      case 0x6526: L_6526: //CA 86 09
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6526);
/* 006 [def:0001] [use:0001] */      case 0x6527: L_6527: //86 09 A6
/* 007 [def:0001] [use:0001] */          ram[0x0009] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6527);
/* 009 [def:0001] [use:0001] */      case 0x6529: L_6529: //A6 18 C9
/* 010 [def:0001] [use:0001] */          X=ram[0x0018];
/* 011 [def:1800] [use:0010] */  //      ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6529);
/* 013 [def:0001] [use:0001] */      case 0x652B: L_652b: //C9 80 6A
/* 014 [def:0101] [use:0000] */          ZN=0x80;
/* 015 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 016 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x652B);
/* 018 [def:0001] [use:0001] */      case 0x652D: L_652d: //6A 18 65
/* 019 [def:10001] [use:2000] */          saveflags = C;
/* 020 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 021 [def:0009] [use:0008] */          A = A >> 1;
/* 022 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x652D);
/* 025 [def:0001] [use:0001] */      case 0x652E: L_652e: //18 65 0A
/* 026 [def:2001] [use:0000] */          C = 0;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x652E);
/* 028 [def:0001] [use:0001] */      case 0x652F: L_652f: //65 0A 18
/* 029 [def:b801] [use:6001] */          ADC(ram[0x000A]);
/* 030 [def:0001] [use:0001] */          //trace_PC(0x652F);
/* 031 [def:0001] [use:0001] */      case 0x6531: L_6531: //18 7D BE
/* 032 [def:2001] [use:0000] */          C = 0;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6531);
/* 034 [def:0001] [use:0001] */      case 0x6532: L_6532: //7D BE 02
/* 035 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02BE + X)]);
/* 036 [def:0001] [use:0001] */          //trace_PC(0x6532);
/* 037 [def:0001] [use:0001] */      case 0x6535: L_6535: //99 BE 02
/* 038 [def:0001] [use:0021] */          ram[(unsigned short)(0x02BE + Y)] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6535);
/* 040 [def:0001] [use:0001] */      case 0x6538: L_6538: //A5 09 7D
/* 041 [def:0009] [use:0001] */          A=ram[0x0009];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x6538);
/* 044 [def:0001] [use:0001] */      case 0x653A: L_653a: //7D 7C 02
/* 045 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x027C + X)]);
/* 046 [def:0001] [use:0001] */          //trace_PC(0x653A);
/* 047 [def:0001] [use:0001] */      case 0x653D: L_653d: //99 7C 02
/* 048 [def:0001] [use:0021] */          ram[(unsigned short)(0x027C + Y)] = A;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x653D);
/* 050 [def:0001] [use:0001] */      case 0x6540: L_6540: //A2 00 A5
/* 051 [def:0001] [use:0001] */          X=0x00;
/* 052 [def:1800] [use:0010] */  //      ZN = X;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6540);
/* 054 [def:0001] [use:0001] */      case 0x6542: L_6542: //A5 0D 10
/* 055 [def:0009] [use:0001] */          A=ram[0x000D];
/* 056 [def:1801] [use:0008] */          ZN = A;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x6542);
/* 058 [def:0001] [use:0001] */      case 0x6544: L_6544: //10 01 CA
/* 059 [def:0001] [use:1001] */          if (ZN < 0)
/* 060 [def:0001] [use:0001] */          {
/* 061 [def:0001] [use:0001] */              //trace_PC(0x6544);
/* 062 [def:0001] [use:0001] */              PC = 0x6547;
/*                           */              clockticks += 90;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6544);
/* 002 [def:0001] [use:0001] */      case 0x6546: L_6546: //CA 86 0C
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6546);
/* 006 [def:0001] [use:0001] */      case 0x6547: L_6547: //86 0C A6
/* 007 [def:0001] [use:0001] */          ram[0x000C] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6547);
/* 009 [def:0001] [use:0001] */      case 0x6549: L_6549: //A6 18 C9
/* 010 [def:0001] [use:0001] */          X=ram[0x0018];
/* 011 [def:1800] [use:0010] */  //      ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6549);
/* 013 [def:0001] [use:0001] */      case 0x654B: L_654b: //C9 80 6A
/* 014 [def:0101] [use:0000] */          ZN=0x80;
/* 015 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 016 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x654B);
/* 018 [def:0001] [use:0001] */      case 0x654D: L_654d: //6A 18 65
/* 019 [def:10001] [use:2000] */          saveflags = C;
/* 020 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 021 [def:0009] [use:0008] */          A = A >> 1;
/* 022 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x654D);
/* 025 [def:0001] [use:0001] */      case 0x654E: L_654e: //18 65 0D
/* 026 [def:2001] [use:0000] */          C = 0;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x654E);
/* 028 [def:0001] [use:0001] */      case 0x654F: L_654f: //65 0D 18
/* 029 [def:b801] [use:6001] */          ADC(ram[0x000D]);
/* 030 [def:0001] [use:0001] */          //trace_PC(0x654F);
/* 031 [def:0001] [use:0001] */      case 0x6551: L_6551: //18 7D DF
/* 032 [def:2001] [use:0000] */          C = 0;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6551);
/* 034 [def:0001] [use:0001] */      case 0x6552: L_6552: //7D DF 02
/* 035 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02DF + X)]);
/* 036 [def:0001] [use:0001] */          //trace_PC(0x6552);
/* 037 [def:0001] [use:0001] */      case 0x6555: L_6555: //99 DF 02
/* 038 [def:0001] [use:0021] */          ram[(unsigned short)(0x02DF + Y)] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6555);
/* 040 [def:0001] [use:0001] */      case 0x6558: L_6558: //A5 0C 7D
/* 041 [def:0009] [use:0001] */          A=ram[0x000C];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x6558);
/* 044 [def:0001] [use:0001] */      case 0x655A: L_655a: //7D 9D 02
/* 045 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x029D + X)]);
/* 046 [def:0001] [use:0001] */          //trace_PC(0x655A);
/* 047 [def:0001] [use:0001] */      case 0x655D: L_655d: //99 9D 02
/* 048 [def:0001] [use:0021] */          ram[(unsigned short)(0x029D + Y)] = A;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x655D);
/* 050 [def:0001] [use:0001] */      case 0x6560: L_6560: //A0 27 E0
/* 051 [def:0021] [use:0000] */          Y=0x27;
/* 052 [def:1800] [use:0020] */  //      ZN = Y;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6560);
/* 054 [def:0001] [use:0001] */      case 0x6562: L_6562: //E0 01 90
/* 055 [def:0101] [use:0000] */          ZN=0x01;
/* 056 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 057 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 058 [def:0001] [use:0001] */          //trace_PC(0x6562);
/* 059 [def:0001] [use:0001] */      case 0x6564: L_6564: //90 02 A0
/* 060 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 061 [def:0001] [use:0001] */          {
/* 062 [def:0001] [use:0001] */              //trace_PC(0x6564);
/* 063 [def:0001] [use:0001] */              PC = 0x6568;
/*                           */              clockticks += 138;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6564);
/* 002 [def:0001] [use:0001] */      case 0x6566: L_6566: //A0 1F 4C
/* 003 [def:0021] [use:0000] */          Y=0x1F;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6566);
/* 006 [def:0001] [use:0001] */      case 0x6568: L_6568: //4C 17 77
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6568);
/* 008 [def:0001] [use:0001] */          PC = 0x7717;
/*                           */          clockticks += 143; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x656B: L_656b: //A5 42 25
/* 001 [def:0009] [use:0001] */          A=ram[0x0042];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x656B);
/* 004 [def:0001] [use:0001] */      case 0x656D: L_656d: //25 43 10
/* 005 [def:0009] [use:0009] */          A &= ram[0x0043];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x656D);
/* 008 [def:0001] [use:0001] */      case 0x656F: L_656f: //10 0A A5
/* 009 [def:0001] [use:1001] */          if (ZN < 0)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x656F);
/* 012 [def:0001] [use:0001] */              PC = 0x657b;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x656F);
/* 002 [def:0001] [use:0001] */      case 0x6571: L_6571: //A5 22 D0
/* 003 [def:0009] [use:0001] */          A=ram[0x0022];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6571);
/* 006 [def:0001] [use:0001] */      case 0x6573: L_6573: //D0 03 20
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6573);
/* 010 [def:0001] [use:0001] */              PC = 0x6578;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6573);
/* 002 [def:0001] [use:0001] */      case 0x6575: L_6575: //20 44 78
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x77;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6575);
/* 006 [def:0001] [use:0001] */          PC = 0x7844;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6578: L_6578: //A9 FF 60
/* 001 [def:0009] [use:0000] */          A=0xFF;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6578);
/* 004 [def:0001] [use:0001] */      case 0x657A: L_657a: //60 A5 21
/* 005 [def:0001] [use:0001] */          //trace_PC(0x657A);
/* 006 [def:0001] [use:0001] */          PC=stack[++S];
/* 007 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 008 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x657B: L_657b: //A5 21 4A
/* 001 [def:0009] [use:0001] */          A=ram[0x0021];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x657B);
/* 004 [def:0001] [use:0001] */      case 0x657D: L_657d: //4A F0 18
/* 005 [def:2001] [use:0008] */          C = A & 0x01;
/* 006 [def:0009] [use:0008] */          A = A >> 1;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x657D);
/* 009 [def:0001] [use:0001] */      case 0x657E: L_657e: //F0 18 A0
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x657E);
/* 013 [def:0001] [use:0001] */              PC = 0x6598;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x657E);
/* 002 [def:0001] [use:0001] */      case 0x6598: L_6598: //46 1E 20
/* 003 [def:0101] [use:0001] */          ZN=ram[0x001E];
/* 004 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 005 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 006 [def:0001] [use:0100] */          ram[0x001E] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6598);
/* 008 [def:0001] [use:0001] */      case 0x659A: L_659a: //20 95 6C
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x9C;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x659A);
/* 012 [def:0001] [use:0001] */          PC = 0x6c95;
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x659D: L_659d: //A0 02 20
/* 001 [def:0021] [use:0000] */          Y=0x02;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x659D);
/* 004 [def:0001] [use:0001] */      case 0x659F: L_659f: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xA1;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x659F);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65A2: L_65a2: //A0 03 20
/* 001 [def:0021] [use:0000] */          Y=0x03;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65A2);
/* 004 [def:0001] [use:0001] */      case 0x65A4: L_65a4: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xA6;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65A4);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65A7: L_65a7: //A0 04 20
/* 001 [def:0021] [use:0000] */          Y=0x04;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65A7);
/* 004 [def:0001] [use:0001] */      case 0x65A9: L_65a9: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xAB;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65A9);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65AC: L_65ac: //A0 05 20
/* 001 [def:0021] [use:0000] */          Y=0x05;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65AC);
/* 004 [def:0001] [use:0001] */      case 0x65AE: L_65ae: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xB0;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65AE);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65B1: L_65b1: //A9 20 85
/* 001 [def:0009] [use:0000] */          A=0x20;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65B1);
/* 004 [def:0001] [use:0001] */      case 0x65B3: L_65b3: //85 01 A9
/* 005 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x65B3);
/* 007 [def:0001] [use:0001] */      case 0x65B5: L_65b5: //A9 64 A2
/* 008 [def:0009] [use:0000] */          A=0x64;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x65B5);
/* 011 [def:0001] [use:0001] */      case 0x65B7: L_65b7: //A2 39 20
/* 012 [def:0001] [use:0001] */          X=0x39;
/* 013 [def:1801] [use:0010] */          ZN = X;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x65B7);
/* 015 [def:0001] [use:0001] */      case 0x65B9: L_65b9: //20 1F 7A
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 017 [def:0001] [use:0001] */          stack[S--] = 0xBB;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x65B9);
/* 019 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65BC: L_65bc: //A9 70 20
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65BC);
/* 004 [def:0001] [use:0001] */      case 0x65BE: L_65be: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xC0;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65BE);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65C1: L_65c1: //A6 1E B4
/* 001 [def:0001] [use:0001] */          X=ram[0x001E];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65C1);
/* 004 [def:0001] [use:0001] */      case 0x65C3: L_65c3: //B4 42 84
/* 005 [def:0001] [use:0011] */          temp=(0x0042 + X)&0xFF;
/* 006 [def:0001] [use:0001] */          Y=ram[temp];
/* 007 [def:0001] [use:0001] */          DO_Z (Y);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x65C3);
/* 009 [def:0001] [use:0001] */      case 0x65C5: L_65c5: //84 0C 98
/* 010 [def:0001] [use:0020] */          ram[0x000C] = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x65C5);
/* 012 [def:0001] [use:0001] */      case 0x65C7: L_65c7: //98 18 65
/* 013 [def:0001] [use:0001] */          A=Y;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x65C7);
/* 016 [def:0001] [use:0001] */      case 0x65C8: L_65c8: //18 65 41
/* 017 [def:2001] [use:0000] */          C = 0;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x65C8);
/* 019 [def:0001] [use:0001] */      case 0x65C9: L_65c9: //65 41 85
/* 020 [def:b801] [use:6001] */          ADC(ram[0x0041]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x65C9);
/* 022 [def:0001] [use:0001] */      case 0x65CB: L_65cb: //85 0D 20
/* 023 [def:0001] [use:0008] */          ram[0x000D] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x65CB);
/* 025 [def:0001] [use:0001] */      case 0x65CD: L_65cd: //20 C5 66
/* 026 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 027 [def:0001] [use:0001] */          stack[S--] = 0xCF;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x65CD);
/* 029 [def:0001] [use:0001] */          PC = 0x66c5;
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65D0: L_65d0: //A4 0C C8
/* 001 [def:0021] [use:0001] */          Y=ram[0x000C];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65D0);
/* 004 [def:0001] [use:0001] */      case 0x65D2: L_65d2: //C8 20 C5
/* 005 [def:0021] [use:0020] */          Y++;
/* 006 [def:1801] [use:0020] */          ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65D2);
/* 008 [def:0001] [use:0001] */      case 0x65D3: L_65d3: //20 C5 66
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0xD5;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x65D3);
/* 012 [def:0001] [use:0001] */          PC = 0x66c5;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65D6: L_65d6: //A4 0C C8
/* 001 [def:0021] [use:0001] */          Y=ram[0x000C];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x65D6);
/* 004 [def:0001] [use:0001] */      case 0x65D8: L_65d8: //C8 C8 20
/* 005 [def:0021] [use:0020] */          Y++;
/* 006 [def:1800] [use:0020] */  //      ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x65D8);
/* 008 [def:0001] [use:0001] */      case 0x65D9: L_65d9: //C8 20 C5
/* 009 [def:0021] [use:0020] */          Y++;
/* 010 [def:1801] [use:0020] */          ZN = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x65D9);
/* 012 [def:0001] [use:0001] */      case 0x65DA: L_65da: //20 C5 66
/* 013 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 014 [def:0001] [use:0001] */          stack[S--] = 0xDC;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x65DA);
/* 016 [def:0001] [use:0001] */          PC = 0x66c5;
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x65DD: L_65dd: //0E 03 20
/* 001 [def:0101] [use:0001] */          ZN=ram[0x2003];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x80;
/* 003 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 004 [def:0001] [use:0100] */          ram[0x2003] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x65DD);
/* 006 [def:0001] [use:0001] */      case 0x65E0: L_65e0: //26 7B A5
/* 007 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 008 [def:0101] [use:0001] */          ZN=ram[0x007B];
/* 009 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 010 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 011 [def:1801] [use:10100] */          ZN |= saveflags;
/* 012 [def:0001] [use:1800] */          ram[0x007B] = ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x65E0);
/* 014 [def:0001] [use:0001] */      case 0x65E2: L_65e2: //A5 7B 29
/* 015 [def:0009] [use:0001] */          A=ram[0x007B];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x65E2);
/* 018 [def:0001] [use:0001] */      case 0x65E4: L_65e4: //29 1F C9
/* 019 [def:0009] [use:0008] */          A &= 0x1F;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x65E4);
/* 022 [def:0001] [use:0001] */      case 0x65E6: L_65e6: //C9 07 D0
/* 023 [def:0101] [use:0000] */          ZN=0x07;
/* 024 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 025 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x65E6);
/* 027 [def:0001] [use:0001] */      case 0x65E8: L_65e8: //D0 2E E6
/* 028 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x65E8);
/* 031 [def:0001] [use:0001] */              PC = 0x6618;
/*                           */              clockticks += 23;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x65E8);
/* 002 [def:0001] [use:0001] */      case 0x65EA: L_65ea: //E6 41 A5
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x0041];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x65EA);
/* 005 [def:0001] [use:0001] */      case 0x65EC: L_65ec: //A5 41 C9
/* 006 [def:0009] [use:0001] */          A=ram[0x0041];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x65EC);
/* 009 [def:0001] [use:0001] */      case 0x65EE: L_65ee: //C9 03 90
/* 010 [def:0101] [use:0000] */          ZN=0x03;
/* 011 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 012 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x65EE);
/* 014 [def:0001] [use:0001] */      case 0x65F0: L_65f0: //90 1A A6
/* 015 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x65F0);
/* 018 [def:0001] [use:0001] */              PC = 0x660c;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x65F0);
/* 002 [def:0001] [use:0001] */      case 0x65F2: L_65f2: //A6 1E A9
/* 003 [def:0001] [use:0001] */          X=ram[0x001E];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x65F2);
/* 006 [def:0001] [use:0001] */      case 0x65F4: L_65f4: //A9 FF 95
/* 007 [def:0009] [use:0000] */          A=0xFF;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x65F4);
/* 010 [def:0001] [use:0001] */      case 0x65F6: L_65f6: //95 42 A2
/* 011 [def:0001] [use:0019] */          ram[(unsigned char)(0x42 + X)] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x65F6);
/* 013 [def:0001] [use:0001] */      case 0x65F8: L_65f8: //A2 00 86
/* 014 [def:0001] [use:0001] */          X=0x00;
/* 015 [def:1800] [use:0010] */  //      ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x65F8);
/* 017 [def:0001] [use:0001] */      case 0x65FA: L_65fa: //86 1E 86
/* 018 [def:0001] [use:0001] */          ram[0x001E] = X;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x65FA);
/* 020 [def:0001] [use:0001] */      case 0x65FC: L_65fc: //86 41 A2
/* 021 [def:0001] [use:0001] */          ram[0x0041] = X;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x65FC);
/* 023 [def:0001] [use:0001] */      case 0x65FE: L_65fe: //A2 F0 86
/* 024 [def:0001] [use:0001] */          X=0xF0;
/* 025 [def:1800] [use:0010] */  //      ZN = X;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x65FE);
/* 027 [def:0001] [use:0001] */      case 0x6600: L_6600: //86 77 A5
/* 028 [def:0001] [use:0001] */          ram[0x0077] = X;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6600);
/* 030 [def:0001] [use:0001] */      case 0x6602: L_6602: //A5 42 10
/* 031 [def:0009] [use:0001] */          A=ram[0x0042];
/* 032 [def:1801] [use:0008] */          ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6602);
/* 034 [def:0001] [use:0001] */      case 0x6604: L_6604: //10 03 20
/* 035 [def:0001] [use:1001] */          if (ZN < 0)
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x6604);
/* 038 [def:0001] [use:0001] */              PC = 0x6609;
/*                           */              clockticks += 63;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6604);
/* 002 [def:0001] [use:0001] */      case 0x6606: L_6606: //20 C7 7B
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x66;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x08;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6606);
/* 006 [def:0001] [use:0001] */          PC = 0x7bc7;
/*                           */          clockticks += 68; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6609: L_6609: //4C 95 6C
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6609);
/* 002 [def:0001] [use:0001] */          PC = 0x6c95;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x660C: L_660c: //E6 0D A6
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x000D];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x660C);
/* 003 [def:0001] [use:0001] */      case 0x660E: L_660e: //A6 0D A9
/* 004 [def:0001] [use:0001] */          X=ram[0x000D];
/* 005 [def:1800] [use:0010] */  //      ZN = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x660E);
/* 007 [def:0001] [use:0001] */      case 0x6610: L_6610: //A9 F4 85
/* 008 [def:0009] [use:0000] */          A=0xF4;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6610);
/* 011 [def:0001] [use:0001] */      case 0x6612: L_6612: //85 77 A9
/* 012 [def:0001] [use:0008] */          ram[0x0077] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6612);
/* 014 [def:0001] [use:0001] */      case 0x6614: L_6614: //A9 0B 95
/* 015 [def:0009] [use:0000] */          A=0x0B;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6614);
/* 018 [def:0001] [use:0001] */      case 0x6616: L_6616: //95 44 A5
/* 019 [def:0001] [use:0019] */          ram[(unsigned char)(0x44 + X)] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6616);
/* 021 [def:0001] [use:0001] */      case 0x6618: L_6618: //A5 77 D0
/* 022 [def:0009] [use:0001] */          A=ram[0x0077];
/* 023 [def:1801] [use:0008] */          ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6618);
/* 025 [def:0001] [use:0001] */      case 0x661A: L_661a: //D0 08 A9
/* 026 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x661A);
/* 029 [def:0001] [use:0001] */              PC = 0x6624;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x661A);
/* 002 [def:0001] [use:0001] */      case 0x6624: L_6624: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6624);
/* 006 [def:0001] [use:0001] */      case 0x6626: L_6626: //29 07 D0
/* 007 [def:0009] [use:0008] */          A &= 0x07;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6626);
/* 010 [def:0001] [use:0001] */      case 0x6628: L_6628: //D0 2C A6
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6628);
/* 014 [def:0001] [use:0001] */              PC = 0x6656;
/*                           */              clockticks += 34;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6628);
/* 002 [def:0001] [use:0001] */      case 0x662A: L_662a: //A6 0D B4
/* 003 [def:0001] [use:0001] */          X=ram[0x000D];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x662A);
/* 006 [def:0001] [use:0001] */      case 0x662C: L_662c: //B4 44 2C
/* 007 [def:0001] [use:0011] */          temp=(0x0044 + X)&0xFF;
/* 008 [def:0001] [use:0001] */          Y=ram[temp];
/* 009 [def:0001] [use:0001] */          DO_Z (Y);
/* 010 [def:0001] [use:0001] */          //trace_PC(0x662C);
/* 011 [def:0001] [use:0001] */      case 0x662E: L_662e: //2C 07 24
/* 012 [def:1101] [use:0001] */          ZN=ram[0x2407];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 013 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 014 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 015 [def:0001] [use:0001] */          //trace_PC(0x662E);
/* 016 [def:0001] [use:0001] */      case 0x6631: L_6631: //10 01 C8
/* 017 [def:0001] [use:1001] */          if (ZN < 0)
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x6631);
/* 020 [def:0001] [use:0001] */              PC = 0x6634;
/*                           */              clockticks += 47;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6631);
/* 002 [def:0001] [use:0001] */      case 0x6634: L_6634: //2C 06 24
/* 003 [def:1101] [use:0001] */          ZN=ram[0x2406];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 004 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 005 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6634);
/* 007 [def:0001] [use:0001] */      case 0x6637: L_6637: //10 03 88
/* 008 [def:0001] [use:1001] */          if (ZN < 0)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6637);
/* 011 [def:0001] [use:0001] */              PC = 0x663c;
/*                           */              clockticks += 53;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6637);
/* 002 [def:0001] [use:0001] */      case 0x6639: L_6639: //88 30 10
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6639);
/* 006 [def:0001] [use:0001] */      case 0x663A: L_663a: //30 10 C0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x663A);
/* 010 [def:0001] [use:0001] */              PC = 0x664c;
/*                           */              clockticks += 57;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x663A);
/* 002 [def:0001] [use:0001] */      case 0x663C: L_663c: //C0 0B B0
/* 003 [def:0101] [use:0001] */          ZN=0x0B;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x663C);
/* 007 [def:0001] [use:0001] */      case 0x663E: L_663e: //B0 0E C0
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x663E);
/* 011 [def:0001] [use:0001] */              PC = 0x664e;
/*                           */              clockticks += 62;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x663E);
/* 002 [def:0001] [use:0001] */      case 0x6640: L_6640: //C0 01 F0
/* 003 [def:0101] [use:0001] */          ZN=0x01;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6640);
/* 007 [def:0001] [use:0001] */      case 0x6642: L_6642: //F0 04 A0
/* 008 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6642);
/* 011 [def:0001] [use:0001] */              PC = 0x6648;
/*                           */              clockticks += 67;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6642);
/* 002 [def:0001] [use:0001] */      case 0x6644: L_6644: //A0 00 F0
/* 003 [def:0021] [use:0000] */          Y=0x00;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6644);
/* 006 [def:0001] [use:0001] */      case 0x6646: L_6646: //F0 0C A0
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6646);
/* 010 [def:0001] [use:0001] */              PC = 0x6654;
/*                           */              clockticks += 72;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6646);
/* 002 [def:0001] [use:0001] */      case 0x6648: L_6648: //A0 0B D0
/* 003 [def:0020] [use:0000] */  //      Y=0x0B;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6648);
/* 006 [def:0001] [use:0001] */      case 0x664C: L_664c: //A0 24 C0
/* 007 [def:0021] [use:0000] */          Y=0x24;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x664C);
/* 010 [def:0001] [use:0001] */      case 0x664E: L_664e: //C0 25 90
/* 011 [def:0101] [use:0001] */          ZN=0x25;
/* 012 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 013 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x664E);
/* 015 [def:0001] [use:0001] */      case 0x6650: L_6650: //90 02 A0
/* 016 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x6650);
/* 019 [def:0001] [use:0001] */              PC = 0x6654;
/*                           */              clockticks += 83;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6650);
/* 002 [def:0001] [use:0001] */      case 0x6654: L_6654: //94 44 A9
/* 003 [def:0001] [use:0011] */          temp=(0x0044 + X)&0xFF;
/* 004 [def:0001] [use:0001] */          ram[temp] = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6654);
/* 006 [def:0001] [use:0001] */      case 0x6656: L_6656: //A9 00 60
/* 007 [def:0009] [use:0000] */          A=0x00;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6656);
/* 010 [def:0001] [use:0001] */      case 0x6658: L_6658: //60 46 73
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6658);
/* 012 [def:0001] [use:0001] */          PC=stack[++S];
/* 013 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 014 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 95; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6659: L_6659: //46 73 A5
/* 001 [def:0101] [use:0001] */          ZN=ram[0x0073];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 003 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 004 [def:0001] [use:0100] */          ram[0x0073] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6659);
/* 006 [def:0001] [use:0001] */      case 0x665B: L_665b: //A5 22 F0
/* 007 [def:0009] [use:0001] */          A=ram[0x0022];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x665B);
/* 010 [def:0001] [use:0001] */      case 0x665D: L_665d: //F0 21 AD
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x665D);
/* 014 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x665D);
/* 002 [def:0001] [use:0001] */      case 0x665F: L_665f: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x665F);
/* 006 [def:0001] [use:0001] */      case 0x6662: L_6662: //30 1C F0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6662);
/* 010 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6662);
/* 002 [def:0001] [use:0001] */      case 0x6664: L_6664: //F0 1A AD
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6664);
/* 006 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6664);
/* 002 [def:0001] [use:0001] */      case 0x6666: L_6666: //AD EF 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EF];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6666);
/* 006 [def:0001] [use:0001] */      case 0x6669: L_6669: //F0 15 0E
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6669);
/* 010 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6669);
/* 002 [def:0001] [use:0001] */      case 0x666B: L_666b: //0E 03 20
/* 003 [def:0101] [use:0001] */          ZN=ram[0x2003];
/* 004 [def:2001] [use:0100] */          C = ZN & 0x80;
/* 005 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 006 [def:0001] [use:0100] */          ram[0x2003] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x666B);
/* 008 [def:0001] [use:0001] */      case 0x666E: L_666e: //66 73 10
/* 009 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 010 [def:0101] [use:0001] */          ZN=ram[0x0073];
/* 011 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 012 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 013 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 014 [def:0001] [use:0100] */          ram[0x0073] = ZN;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x666E);
/* 016 [def:0001] [use:0001] */      case 0x6670: L_6670: //10 0E A0
/* 017 [def:0001] [use:1001] */          if (ZN < 0)
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x6670);
/* 020 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 38;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6670);
/* 002 [def:0001] [use:0001] */      case 0x6672: L_6672: //A0 57 20
/* 003 [def:0021] [use:0000] */          Y=0x57;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6672);
/* 006 [def:0001] [use:0001] */      case 0x6674: L_6674: //20 13 77
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x66;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x76;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6674);
/* 010 [def:0001] [use:0001] */          PC = 0x7713;
/*                           */          clockticks += 46; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6677: L_6677: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6677);
/* 004 [def:0001] [use:0001] */      case 0x6679: L_6679: //29 03 D0
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6679);
/* 008 [def:0001] [use:0001] */      case 0x667B: L_667b: //D0 03 CE
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x667B);
/* 012 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x667B);
/* 002 [def:0001] [use:0001] */      case 0x667D: L_667d: //CE EF 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02EF];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x667D);
/* 005 [def:0001] [use:0001] */      case 0x6680: L_6680: //60 24 73
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6680);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 20; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6681: L_6681: //24 73 10
/* 001 [def:1101] [use:0001] */          ZN=ram[0x0073];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6681);
/* 005 [def:0001] [use:0001] */      case 0x6683: L_6683: //10 FB AD
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6683);
/* 009 [def:0001] [use:0001] */              PC = 0x6680;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6683);
/* 002 [def:0001] [use:0001] */      case 0x6685: L_6685: //AD EF 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02EF];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6685);
/* 006 [def:0001] [use:0001] */      case 0x6688: L_6688: //29 F0 C9
/* 007 [def:0009] [use:0008] */          A &= 0xF0;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6688);
/* 010 [def:0001] [use:0001] */      case 0x668A: L_668a: //C9 60 B0
/* 011 [def:0101] [use:0000] */          ZN=0x60;
/* 012 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 013 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x668A);
/* 015 [def:0001] [use:0001] */      case 0x668C: L_668c: //B0 02 A9
/* 016 [def:0001] [use:2001] */          if (C)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x668C);
/* 019 [def:0001] [use:0001] */              PC = 0x6690;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x668C);
/* 002 [def:0001] [use:0001] */      case 0x668E: L_668e: //A9 60 48
/* 003 [def:0008] [use:0000] */  //      A=0x60;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x668E);
/* 006 [def:0001] [use:0001] */      case 0x6690: L_6690: //48 A2 12
/* 007 [def:0001] [use:0001] */          stack[S--] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6690);
/* 009 [def:0001] [use:0001] */      case 0x6691: L_6691: //A2 12 A9
/* 010 [def:0001] [use:0001] */          X=0x12;
/* 011 [def:1800] [use:0010] */  //      ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6691);
/* 013 [def:0001] [use:0001] */      case 0x6693: L_6693: //A9 50 86
/* 014 [def:0009] [use:0000] */          A=0x50;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6693);
/* 017 [def:0001] [use:0001] */      case 0x6695: L_6695: //86 10 85
/* 018 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6695);
/* 020 [def:0001] [use:0001] */      case 0x6697: L_6697: //85 11 A2
/* 021 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6697);
/* 023 [def:0001] [use:0001] */      case 0x6699: L_6699: //A2 00 86
/* 024 [def:0001] [use:0001] */          X=0x00;
/* 025 [def:1801] [use:0010] */          ZN = X;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6699);
/* 027 [def:0001] [use:0001] */      case 0x669B: L_669b: //86 09 86
/* 028 [def:0001] [use:0001] */          ram[0x0009] = X;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x669B);
/* 030 [def:0001] [use:0001] */      case 0x669D: L_669d: //86 0A 86
/* 031 [def:0001] [use:0001] */          ram[0x000A] = X;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x669D);
/* 033 [def:0001] [use:0001] */      case 0x669F: L_669f: //86 12 20
/* 034 [def:0001] [use:0001] */          ram[0x0012] = X;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x669F);
/* 036 [def:0001] [use:0001] */      case 0x66A1: L_66a1: //20 21 62
/* 037 [def:0001] [use:0001] */          stack[S--] = 0x66;
/* 038 [def:0001] [use:0001] */          stack[S--] = 0xA3;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x66A1);
/* 040 [def:0001] [use:0001] */          PC = 0x6221;
/*                           */          clockticks += 48; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66A4: L_66a4: //A2 07 68
/* 001 [def:0001] [use:0001] */          X=0x07;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x66A4);
/* 004 [def:0001] [use:0001] */      case 0x66A6: L_66a6: //68 85 09
/* 005 [def:0001] [use:0001] */          A=stack[++S];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x66A6);
/* 008 [def:0001] [use:0001] */      case 0x66A7: L_66a7: //85 09 20
/* 009 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x66A7);
/* 011 [def:0001] [use:0001] */      case 0x66A9: L_66a9: //20 96 6E
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x66;
/* 013 [def:0001] [use:0001] */          stack[S--] = 0xAB;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x66A9);
/* 015 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 15; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66AC: L_66ac: //A9 00 85
/* 001 [def:0009] [use:0000] */          A=0x00;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x66AC);
/* 004 [def:0001] [use:0001] */      case 0x66AE: L_66ae: //85 09 4C
/* 005 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x66AE);
/* 007 [def:0001] [use:0001] */      case 0x66B0: L_66b0: //4C 96 6E
/* 008 [def:0001] [use:0001] */          //trace_PC(0x66B0);
/* 009 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66C5: L_66c5: //B9 44 00
/* 001 [def:0009] [use:0021] */          A=ram[0x0044 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x66C5);
/* 004 [def:0001] [use:0001] */      case 0x66C8: L_66c8: //0A A8 D0
/* 005 [def:2001] [use:0008] */          C = A & 0x80;
/* 006 [def:0009] [use:0008] */          A = A << 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x66C8);
/* 009 [def:0001] [use:0001] */      case 0x66C9: L_66c9: //A8 D0 0D
/* 010 [def:0021] [use:0008] */          Y=A;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x66C9);
/* 013 [def:0001] [use:0001] */      case 0x66CA: L_66ca: //D0 0D A5
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x66CA);
/* 017 [def:0001] [use:0001] */              PC = 0x66d9;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66CA);
/* 002 [def:0001] [use:0001] */      case 0x66CC: L_66cc: //A5 42 25
/* 003 [def:0009] [use:0001] */          A=ram[0x0042];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x66CC);
/* 006 [def:0001] [use:0001] */      case 0x66CE: L_66ce: //25 43 30
/* 007 [def:0009] [use:0009] */          A &= ram[0x0043];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x66CE);
/* 010 [def:0001] [use:0001] */      case 0x66D0: L_66d0: //30 07 A2
/* 011 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x66D0);
/* 014 [def:0001] [use:0001] */              PC = 0x66d9;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66D0);
/* 002 [def:0001] [use:0001] */      case 0x66D2: L_66d2: //A2 B0 A9
/* 003 [def:0001] [use:0001] */          X=0xB0;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x66D2);
/* 006 [def:0001] [use:0001] */      case 0x66D4: L_66d4: //A9 56 4C
/* 007 [def:0009] [use:0000] */          A=0x56;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x66D4);
/* 010 [def:0001] [use:0001] */      case 0x66D6: L_66d6: //4C 18 7A
/* 011 [def:0001] [use:0001] */          //trace_PC(0x66D6);
/* 012 [def:0001] [use:0001] */          PC = 0x7a18;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66D9: L_66d9: //4C F8 79
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66D9);
/* 002 [def:0001] [use:0001] */          PC = 0x79f8;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66DC: L_66dc: //A2 20 A9
/* 001 [def:0001] [use:0001] */          X=0x20;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x66DC);
/* 004 [def:0001] [use:0001] */      case 0x66DE: L_66de: //A9 00 85
/* 005 [def:0009] [use:0000] */          A=0x00;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x66DE);
/* 008 [def:0001] [use:0001] */      case 0x66E0: L_66e0: //85 19 BD
/* 009 [def:0001] [use:0008] */          ram[0x0019] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x66E0);
/* 011 [def:0001] [use:0001] */      case 0x66E2: L_66e2: //BD 00 02
/* 012 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x66E2);
/* 015 [def:0001] [use:0001] */      case 0x66E5: L_66e5: //D0 04 CA
/* 016 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x66E5);
/* 019 [def:0001] [use:0001] */              PC = 0x66eb;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66E5);
/* 002 [def:0001] [use:0001] */      case 0x66E7: L_66e7: //CA 10 F8
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x66E7);
/* 006 [def:0001] [use:0001] */      case 0x66E8: L_66e8: //10 F8 60
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x66E8);
/* 010 [def:0001] [use:0001] */              PC = 0x66e2;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66E8);
/* 002 [def:0001] [use:0001] */      case 0x66EA: L_66ea: //60 10 63
/* 003 [def:0001] [use:0001] */          //trace_PC(0x66EA);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66EB: L_66eb: //10 63 20
/* 001 [def:0001] [use:1001] */          if (ZN < 0)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x66EB);
/* 004 [def:0001] [use:0001] */              PC = 0x6750;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66EB);
/* 002 [def:0001] [use:0001] */      case 0x66ED: L_66ed: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x66;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xEF;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x66ED);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x66F0: L_66f0: //4A 4A 4A
/* 001 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 002 [def:0009] [use:0008] */          A = A >> 1;
/* 003 [def:1800] [use:0008] */  //      ZN = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x66F0);
/* 005 [def:0001] [use:0001] */      case 0x66F1: L_66f1: //4A 4A 4A
/* 006 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 007 [def:0009] [use:0008] */          A = A >> 1;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x66F1);
/* 010 [def:0001] [use:0001] */      case 0x66F2: L_66f2: //4A 4A E0
/* 011 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x66F2);
/* 015 [def:0001] [use:0001] */      case 0x66F3: L_66f3: //4A E0 19
/* 016 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 017 [def:0009] [use:0008] */          A = A >> 1;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x66F3);
/* 020 [def:0001] [use:0001] */      case 0x66F4: L_66f4: //E0 19 D0
/* 021 [def:0101] [use:0000] */          ZN=0x19;
/* 022 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 023 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x66F4);
/* 025 [def:0001] [use:0001] */      case 0x66F6: L_66f6: //D0 07 A5
/* 026 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x66F6);
/* 029 [def:0001] [use:0001] */              PC = 0x66ff;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66F6);
/* 002 [def:0001] [use:0001] */      case 0x66F8: L_66f8: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x66F8);
/* 006 [def:0001] [use:0001] */      case 0x66FA: L_66fa: //29 01 4A
/* 007 [def:0009] [use:0008] */          A &= 0x01;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x66FA);
/* 010 [def:0001] [use:0001] */      case 0x66FC: L_66fc: //4A F0 01
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x66FC);
/* 015 [def:0001] [use:0001] */      case 0x66FD: L_66fd: //F0 01 38
/* 016 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x66FD);
/* 019 [def:0001] [use:0001] */              PC = 0x6700;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x66FD);
/* 002 [def:0001] [use:0001] */      case 0x66FF: L_66ff: //38 7D 00
/* 003 [def:2001] [use:0000] */          C = 1;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x66FF);
/* 005 [def:0001] [use:0001] */      case 0x6700: L_6700: //7D 00 02
/* 006 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0200 + X)]);
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6700);
/* 008 [def:0001] [use:0001] */      case 0x6703: L_6703: //30 25 E0
/* 009 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6703);
/* 012 [def:0001] [use:0001] */              PC = 0x672a;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6703);
/* 002 [def:0001] [use:0001] */      case 0x6705: L_6705: //E0 19 F0
/* 003 [def:0101] [use:0000] */          ZN=0x19;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6705);
/* 007 [def:0001] [use:0001] */      case 0x6707: L_6707: //F0 13 B0
/* 008 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6707);
/* 011 [def:0001] [use:0001] */              PC = 0x671c;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6707);
/* 002 [def:0001] [use:0001] */      case 0x6709: L_6709: //B0 17 CE
/* 003 [def:0001] [use:2001] */          if (C)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6709);
/* 006 [def:0001] [use:0001] */              PC = 0x6722;
/*                           */              clockticks += 39;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6709);
/* 002 [def:0001] [use:0001] */      case 0x670B: L_670b: //CE E7 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02E7];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x670B);
/* 005 [def:0001] [use:0001] */      case 0x670E: L_670e: //D0 05 A0
/* 006 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x670E);
/* 009 [def:0001] [use:0001] */              PC = 0x6715;
/*                           */              clockticks += 47;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x670E);
/* 002 [def:0001] [use:0001] */      case 0x6710: L_6710: //A0 7F 8C
/* 003 [def:0021] [use:0000] */          Y=0x7F;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6710);
/* 006 [def:0001] [use:0001] */      case 0x6712: L_6712: //8C EC 02
/* 007 [def:0001] [use:0001] */          ram[0x02EC] = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6712);
/* 009 [def:0001] [use:0001] */      case 0x6715: L_6715: //A9 00 9D
/* 010 [def:0009] [use:0000] */          A=0x00;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6715);
/* 013 [def:0001] [use:0001] */      case 0x6717: L_6717: //9D 00 02
/* 014 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6717);
/* 016 [def:0001] [use:0001] */      case 0x671A: L_671a: //F0 CB 20
/* 017 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x671A);
/* 020 [def:0001] [use:0001] */              PC = 0x66e7;
/*                           */              clockticks += 64;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x671A);
/* 002 [def:0001] [use:0001] */      case 0x671C: L_671c: //20 1B 6A
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x67;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x1E;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x671C);
/* 006 [def:0001] [use:0001] */          PC = 0x6a1b;
/*                           */          clockticks += 69; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x671F: L_671f: //4C 15 67
/* 001 [def:0001] [use:0001] */          //trace_PC(0x671F);
/* 002 [def:0001] [use:0001] */          PC = 0x6715;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6722: L_6722: //AD E9 02
/* 001 [def:0009] [use:0001] */          A=ram[0x02E9];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6722);
/* 004 [def:0001] [use:0001] */      case 0x6725: L_6725: //8D E8 02
/* 005 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6725);
/* 007 [def:0001] [use:0001] */      case 0x6728: L_6728: //D0 EB 9D
/* 008 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6728);
/* 011 [def:0001] [use:0001] */              PC = 0x6715;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6728);
/* 002 [def:0001] [use:0001] */      case 0x672A: L_672a: //9D 00 02
/* 003 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x672A);
/* 005 [def:0001] [use:0001] */      case 0x672D: L_672d: //29 F0 18
/* 006 [def:0009] [use:0008] */          A &= 0xF0;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x672D);
/* 009 [def:0001] [use:0001] */      case 0x672F: L_672f: //18 69 10
/* 010 [def:2001] [use:0000] */          C = 0;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x672F);
/* 012 [def:0001] [use:0001] */      case 0x6730: L_6730: //69 10 E0
/* 013 [def:b801] [use:6001] */          ADC(0x10);
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6730);
/* 015 [def:0001] [use:0001] */      case 0x6732: L_6732: //E0 19 D0
/* 016 [def:0101] [use:0000] */          ZN=0x19;
/* 017 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 018 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6732);
/* 020 [def:0001] [use:0001] */      case 0x6734: L_6734: //D0 02 A9
/* 021 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x6734);
/* 024 [def:0001] [use:0001] */              PC = 0x6738;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6734);
/* 002 [def:0001] [use:0001] */      case 0x6736: L_6736: //A9 F0 A8
/* 003 [def:0009] [use:0000] */          A=0xF0;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6736);
/* 006 [def:0001] [use:0001] */      case 0x6738: L_6738: //A8 BD A5
/* 007 [def:0021] [use:0008] */          Y=A;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6738);
/* 010 [def:0001] [use:0001] */      case 0x6739: L_6739: //BD A5 02
/* 011 [def:0009] [use:0011] */          A=ram[0x02A5 + X /* can't wrap */];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6739);
/* 014 [def:0001] [use:0001] */      case 0x673C: L_673c: //85 05 BD
/* 015 [def:0001] [use:0008] */          ram[0x0005] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x673C);
/* 017 [def:0001] [use:0001] */      case 0x673E: L_673e: //BD 63 02
/* 018 [def:0009] [use:0011] */          A=ram[0x0263 + X /* can't wrap */];
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x673E);
/* 021 [def:0001] [use:0001] */      case 0x6741: L_6741: //85 06 BD
/* 022 [def:0001] [use:0008] */          ram[0x0006] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6741);
/* 024 [def:0001] [use:0001] */      case 0x6743: L_6743: //BD C6 02
/* 025 [def:0009] [use:0011] */          A=ram[0x02C6 + X /* can't wrap */];
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6743);
/* 028 [def:0001] [use:0001] */      case 0x6746: L_6746: //85 07 BD
/* 029 [def:0001] [use:0008] */          ram[0x0007] = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6746);
/* 031 [def:0001] [use:0001] */      case 0x6748: L_6748: //BD 84 02
/* 032 [def:0009] [use:0011] */          A=ram[0x0284 + X /* can't wrap */];
/* 033 [def:1801] [use:0008] */          ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x6748);
/* 035 [def:0001] [use:0001] */      case 0x674B: L_674b: //85 08 4C
/* 036 [def:0001] [use:0008] */          ram[0x0008] = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x674B);
/* 038 [def:0001] [use:0001] */      case 0x674D: L_674d: //4C E5 67
/* 039 [def:0001] [use:0001] */          //trace_PC(0x674D);
/* 040 [def:0001] [use:0001] */          PC = 0x67e5;
/*                           */          clockticks += 60; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6750: L_6750: //85 1B 06
/* 001 [def:0001] [use:0008] */          ram[0x001B] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6750);
/* 003 [def:0001] [use:0001] */      case 0x6752: L_6752: //06 1B 10
/* 004 [def:0101] [use:0001] */          ZN=ram[0x001B];
/* 005 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 006 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 007 [def:0001] [use:1800] */          ram[0x001B] = ZN; /* Because at this point it actually has the correct value in it */
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6752);
/* 009 [def:0001] [use:0001] */      case 0x6754: L_6754: //10 15 E0
/* 010 [def:0001] [use:1001] */          if (ZN < 0)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6754);
/* 013 [def:0001] [use:0001] */              PC = 0x676b;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6754);
/* 002 [def:0001] [use:0001] */      case 0x6756: L_6756: //E0 19 B0
/* 003 [def:0101] [use:0000] */          ZN=0x19;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6756);
/* 007 [def:0001] [use:0001] */      case 0x6758: L_6758: //B0 11 29
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6758);
/* 011 [def:0001] [use:0001] */              PC = 0x676b;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6758);
/* 002 [def:0001] [use:0001] */      case 0x675A: L_675a: //29 3C 4A
/* 003 [def:0009] [use:0008] */          A &= 0x3C;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x675A);
/* 006 [def:0001] [use:0001] */      case 0x675C: L_675c: //4A 4A A8
/* 007 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 008 [def:0009] [use:0008] */          A = A >> 1;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x675C);
/* 011 [def:0001] [use:0001] */      case 0x675D: L_675d: //4A A8 84
/* 012 [def:2001] [use:0008] */          C = A & 0x01;
/* 013 [def:0009] [use:0008] */          A = A >> 1;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x675D);
/* 016 [def:0001] [use:0001] */      case 0x675E: L_675e: //A8 84 1C
/* 017 [def:0021] [use:0008] */          Y=A;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x675E);
/* 020 [def:0001] [use:0001] */      case 0x675F: L_675f: //84 1C B9
/* 021 [def:0001] [use:0020] */          ram[0x001C] = Y;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x675F);
/* 023 [def:0001] [use:0001] */      case 0x6761: L_6761: //B9 F8 02
/* 024 [def:0009] [use:0021] */          A=ram[0x02F8 + Y /* can't wrap */];
/* 025 [def:1801] [use:0008] */          ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6761);
/* 027 [def:0001] [use:0001] */      case 0x6764: L_6764: //85 1D 30
/* 028 [def:0001] [use:0008] */          ram[0x001D] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6764);
/* 030 [def:0001] [use:0001] */      case 0x6766: L_6766: //30 03 20
/* 031 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 032 [def:0001] [use:0001] */          {
/* 033 [def:0001] [use:0001] */              //trace_PC(0x6766);
/* 034 [def:0001] [use:0001] */              PC = 0x676b;
/*                           */              clockticks += 34;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6766);
/* 002 [def:0001] [use:0001] */      case 0x6768: L_6768: //20 BE 48
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x67;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6768);
/* 006 [def:0001] [use:0001] */          PC = 0x48be;
/*                           */          clockticks += 39; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x676B: L_676b: //A0 00 18
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x676B);
/* 004 [def:0001] [use:0001] */      case 0x676D: L_676d: //18 BD 21
/* 005 [def:2001] [use:0000] */          C = 0;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x676D);
/* 007 [def:0001] [use:0001] */      case 0x676E: L_676e: //BD 21 02
/* 008 [def:0009] [use:0011] */          A=ram[0x0221 + X /* can't wrap */];
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x676E);
/* 011 [def:0001] [use:0001] */      case 0x6771: L_6771: //10 01 88
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6771);
/* 015 [def:0001] [use:0001] */              PC = 0x6774;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6771);
/* 002 [def:0001] [use:0001] */      case 0x6773: L_6773: //88 7D A5
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6773);
/* 006 [def:0001] [use:0001] */      case 0x6774: L_6774: //7D A5 02
/* 007 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02A5 + X)]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6774);
/* 009 [def:0001] [use:0001] */      case 0x6777: L_6777: //9D A5 02
/* 010 [def:0001] [use:0019] */          ram[0x02A5 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6777);
/* 012 [def:0001] [use:0001] */      case 0x677A: L_677a: //85 05 98
/* 013 [def:0001] [use:0008] */          ram[0x0005] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x677A);
/* 015 [def:0001] [use:0001] */      case 0x677C: L_677c: //98 7D 63
/* 016 [def:0001] [use:0001] */          A=Y;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x677C);
/* 019 [def:0001] [use:0001] */      case 0x677D: L_677d: //7D 63 02
/* 020 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0263 + X)]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x677D);
/* 022 [def:0001] [use:0001] */      case 0x6780: L_6780: //C9 20 90
/* 023 [def:0101] [use:0000] */          ZN=0x20;
/* 024 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 025 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6780);
/* 027 [def:0001] [use:0001] */      case 0x6782: L_6782: //90 2A E0
/* 028 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x6782);
/* 031 [def:0001] [use:0001] */              PC = 0x67ae;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6782);
/* 002 [def:0001] [use:0001] */      case 0x6784: L_6784: //E0 1A D0
/* 003 [def:0101] [use:0000] */          ZN=0x1A;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6784);
/* 007 [def:0001] [use:0001] */      case 0x6786: L_6786: //D0 06 20
/* 008 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6786);
/* 011 [def:0001] [use:0001] */              PC = 0x678e;
/*                           */              clockticks += 41;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6786);
/* 002 [def:0001] [use:0001] */      case 0x6788: L_6788: //20 EB 67
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x67;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x8A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6788);
/* 006 [def:0001] [use:0001] */          PC = 0x67eb;
/*                           */          clockticks += 46; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x678B: L_678b: //4C E7 66
/* 001 [def:0001] [use:0001] */          //trace_PC(0x678B);
/* 002 [def:0001] [use:0001] */          PC = 0x66e7;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x678E: L_678e: //24 1B 10
/* 001 [def:1101] [use:0001] */          ZN=ram[0x001B];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x678E);
/* 005 [def:0001] [use:0001] */      case 0x6790: L_6790: //10 1A A4
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6790);
/* 009 [def:0001] [use:0001] */              PC = 0x67ac;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6790);
/* 002 [def:0001] [use:0001] */      case 0x6792: L_6792: //A4 1D 30
/* 003 [def:0021] [use:0001] */          Y=ram[0x001D];
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6792);
/* 006 [def:0001] [use:0001] */      case 0x6794: L_6794: //30 16 C0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6794);
/* 010 [def:0001] [use:0001] */              PC = 0x67ac;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6794);
/* 002 [def:0001] [use:0001] */      case 0x6796: L_6796: //C0 04 B0
/* 003 [def:0101] [use:0001] */          ZN=0x04;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6796);
/* 007 [def:0001] [use:0001] */      case 0x6798: L_6798: //B0 12 CE
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6798);
/* 011 [def:0001] [use:0001] */              PC = 0x67ac;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6798);
/* 002 [def:0001] [use:0001] */      case 0x679A: L_679a: //CE E7 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02E7];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x679A);
/* 005 [def:0001] [use:0001] */      case 0x679D: L_679d: //CE FF 02
/* 006 [def:1801] [use:0001] */          ZN=--ram[0x02FF];
/* 007 [def:0001] [use:0001] */          //trace_PC(0x679D);
/* 008 [def:0001] [use:0001] */      case 0x67A0: L_67a0: //A4 1C A9
/* 009 [def:0021] [use:0001] */          Y=ram[0x001C];
/* 010 [def:1800] [use:0020] */  //      ZN = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x67A0);
/* 012 [def:0001] [use:0001] */      case 0x67A2: L_67a2: //A9 00 9D
/* 013 [def:0009] [use:0000] */          A=0x00;
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x67A2);
/* 016 [def:0001] [use:0001] */      case 0x67A4: L_67a4: //9D 00 02
/* 017 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x67A4);
/* 019 [def:0001] [use:0001] */      case 0x67A7: L_67a7: //99 F8 02
/* 020 [def:0001] [use:0021] */          ram[(unsigned short)(0x02F8 + Y)] = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x67A7);
/* 022 [def:0001] [use:0001] */      case 0x67AA: L_67aa: //F0 DF 29
/* 023 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 024 [def:0001] [use:0001] */          {
/* 025 [def:0001] [use:0001] */              //trace_PC(0x67AA);
/* 026 [def:0001] [use:0001] */              PC = 0x678b;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67AA);
/* 002 [def:0001] [use:0001] */      case 0x67AC: L_67ac: //29 1F 9D
/* 003 [def:0009] [use:0008] */          A &= 0x1F;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x67AC);
/* 006 [def:0001] [use:0001] */      case 0x67AE: L_67ae: //9D 63 02
/* 007 [def:0001] [use:0019] */          ram[0x0263 + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x67AE);
/* 009 [def:0001] [use:0001] */      case 0x67B1: L_67b1: //29 7F 85
/* 010 [def:0009] [use:0008] */          A &= 0x7F;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x67B1);
/* 013 [def:0001] [use:0001] */      case 0x67B3: L_67b3: //85 06 18
/* 014 [def:0001] [use:0008] */          ram[0x0006] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x67B3);
/* 016 [def:0001] [use:0001] */      case 0x67B5: L_67b5: //18 A0 00
/* 017 [def:2001] [use:0000] */          C = 0;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x67B5);
/* 019 [def:0001] [use:0001] */      case 0x67B6: L_67b6: //A0 00 BD
/* 020 [def:0021] [use:0000] */          Y=0x00;
/* 021 [def:1800] [use:0020] */  //      ZN = Y;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x67B6);
/* 023 [def:0001] [use:0001] */      case 0x67B8: L_67b8: //BD 42 02
/* 024 [def:0009] [use:0011] */          A=ram[0x0242 + X /* can't wrap */];
/* 025 [def:1801] [use:0008] */          ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x67B8);
/* 027 [def:0001] [use:0001] */      case 0x67BB: L_67bb: //10 01 88
/* 028 [def:0001] [use:1001] */          if (ZN < 0)
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x67BB);
/* 031 [def:0001] [use:0001] */              PC = 0x67be;
/*                           */              clockticks += 70;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67BB);
/* 002 [def:0001] [use:0001] */      case 0x67BD: L_67bd: //88 7D C6
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x67BD);
/* 006 [def:0001] [use:0001] */      case 0x67BE: L_67be: //7D C6 02
/* 007 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x02C6 + X)]);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x67BE);
/* 009 [def:0001] [use:0001] */      case 0x67C1: L_67c1: //9D C6 02
/* 010 [def:0001] [use:0019] */          ram[0x02C6 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x67C1);
/* 012 [def:0001] [use:0001] */      case 0x67C4: L_67c4: //85 07 98
/* 013 [def:0001] [use:0008] */          ram[0x0007] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x67C4);
/* 015 [def:0001] [use:0001] */      case 0x67C6: L_67c6: //98 7D 84
/* 016 [def:0001] [use:0001] */          A=Y;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x67C6);
/* 019 [def:0001] [use:0001] */      case 0x67C7: L_67c7: //7D 84 02
/* 020 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0284 + X)]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x67C7);
/* 022 [def:0001] [use:0001] */      case 0x67CA: L_67ca: //C9 18 90
/* 023 [def:0101] [use:0000] */          ZN=0x18;
/* 024 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 025 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x67CA);
/* 027 [def:0001] [use:0001] */      case 0x67CC: L_67cc: //90 08 F0
/* 028 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x67CC);
/* 031 [def:0001] [use:0001] */              PC = 0x67d6;
/*                           */              clockticks += 94;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67CC);
/* 002 [def:0001] [use:0001] */      case 0x67CE: L_67ce: //F0 04 A9
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x67CE);
/* 006 [def:0001] [use:0001] */              PC = 0x67d4;
/*                           */              clockticks += 96;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67CE);
/* 002 [def:0001] [use:0001] */      case 0x67D0: L_67d0: //A9 17 D0
/* 003 [def:0009] [use:0000] */          A=0x17;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x67D0);
/* 006 [def:0001] [use:0001] */      case 0x67D2: L_67d2: //D0 02 A9
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x67D2);
/* 010 [def:0001] [use:0001] */              PC = 0x67d6;
/*                           */              clockticks += 101;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67D2);
/* 002 [def:0001] [use:0001] */      case 0x67D4: L_67d4: //A9 00 9D
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x67D4);
/* 006 [def:0001] [use:0001] */      case 0x67D6: L_67d6: //9D 84 02
/* 007 [def:0001] [use:0019] */          ram[0x0284 + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x67D6);
/* 009 [def:0001] [use:0001] */      case 0x67D9: L_67d9: //85 08 BD
/* 010 [def:0001] [use:0008] */          ram[0x0008] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x67D9);
/* 012 [def:0001] [use:0001] */      case 0x67DB: L_67db: //BD 00 02
/* 013 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x67DB);
/* 016 [def:0001] [use:0001] */      case 0x67DE: L_67de: //29 03 A8
/* 017 [def:0009] [use:0008] */          A &= 0x03;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x67DE);
/* 020 [def:0001] [use:0001] */      case 0x67E0: L_67e0: //A8 B9 0C
/* 021 [def:0021] [use:0008] */          Y=A;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x67E0);
/* 024 [def:0001] [use:0001] */      case 0x67E1: L_67e1: //B9 0C 68
/* 025 [def:0009] [use:0021] */          A=ram[0x680C + Y /* can't wrap */];
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x67E1);
/* 028 [def:0001] [use:0001] */      case 0x67E4: L_67e4: //A8 20 A8
/* 029 [def:0021] [use:0008] */          Y=A;
/* 030 [def:1801] [use:0008] */          ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x67E4);
/* 032 [def:0001] [use:0001] */      case 0x67E5: L_67e5: //20 A8 6B
/* 033 [def:0001] [use:0001] */          stack[S--] = 0x67;
/* 034 [def:0001] [use:0001] */          stack[S--] = 0xE7;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x67E5);
/* 036 [def:0001] [use:0001] */          PC = 0x6ba8;
/*                           */          clockticks += 131; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x67E8: L_67e8: //4C E7 66
/* 001 [def:0001] [use:0001] */          //trace_PC(0x67E8);
/* 002 [def:0001] [use:0001] */          PC = 0x66e7;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x67EB: L_67eb: //AD E9 02
/* 001 [def:0009] [use:0001] */          A=ram[0x02E9];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x67EB);
/* 004 [def:0001] [use:0001] */      case 0x67EE: L_67ee: //8D E8 02
/* 005 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x67EE);
/* 007 [def:0001] [use:0001] */      case 0x67F1: L_67f1: //98 48 A0
/* 008 [def:0001] [use:0001] */          A=Y;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x67F1);
/* 011 [def:0001] [use:0001] */      case 0x67F2: L_67f2: //48 A0 17
/* 012 [def:0001] [use:0001] */          stack[S--] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x67F2);
/* 014 [def:0001] [use:0001] */      case 0x67F3: L_67f3: //A0 17 20
/* 015 [def:0021] [use:0000] */          Y=0x17;
/* 016 [def:1801] [use:0020] */          ZN = Y;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x67F3);
/* 018 [def:0001] [use:0001] */      case 0x67F5: L_67f5: //20 0D 77
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x67;
/* 020 [def:0001] [use:0001] */          stack[S--] = 0xF7;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x67F5);
/* 022 [def:0001] [use:0001] */          PC = 0x770d;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x67F8: L_67f8: //68 A8 A9
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x67F8);
/* 004 [def:0001] [use:0001] */      case 0x67F9: L_67f9: //A8 A9 00
/* 005 [def:0021] [use:0008] */          Y=A;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x67F9);
/* 008 [def:0001] [use:0001] */      case 0x67FA: L_67fa: //A9 00 8D
/* 009 [def:0009] [use:0000] */          A=0x00;
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x67FA);
/* 012 [def:0001] [use:0001] */      case 0x67FC: L_67fc: //8D 1A 02
/* 013 [def:0001] [use:0008] */          ram[0x021A] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x67FC);
/* 015 [def:0001] [use:0001] */      case 0x67FF: L_67ff: //8D 3B 02
/* 016 [def:0001] [use:0008] */          ram[0x023B] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x67FF);
/* 018 [def:0001] [use:0001] */      case 0x6802: L_6802: //8D 5C 02
/* 019 [def:0001] [use:0008] */          ram[0x025C] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6802);
/* 021 [def:0001] [use:0001] */      case 0x6805: L_6805: //8D 7D 02
/* 022 [def:0001] [use:0008] */          ram[0x027D] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6805);
/* 024 [def:0001] [use:0001] */      case 0x6808: L_6808: //8D BF 02
/* 025 [def:0001] [use:0008] */          ram[0x02BF] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6808);
/* 027 [def:0001] [use:0001] */      case 0x680B: L_680b: //60 00 E0
/* 028 [def:0001] [use:0001] */          //trace_PC(0x680B);
/* 029 [def:0001] [use:0001] */          PC=stack[++S];
/* 030 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 031 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 35; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6810: L_6810: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6810);
/* 004 [def:0001] [use:0001] */      case 0x6812: L_6812: //F0 F7 AD
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6812);
/* 008 [def:0001] [use:0001] */              PC = 0x680b;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6812);
/* 002 [def:0001] [use:0001] */      case 0x6814: L_6814: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6814);
/* 006 [def:0001] [use:0001] */      case 0x6817: L_6817: //30 F2 D0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6817);
/* 010 [def:0001] [use:0001] */              PC = 0x680b;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6817);
/* 002 [def:0001] [use:0001] */      case 0x6819: L_6819: //D0 16 CE
/* 003 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6819);
/* 006 [def:0001] [use:0001] */              PC = 0x6831;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6819);
/* 002 [def:0001] [use:0001] */      case 0x681B: L_681b: //CE EB 02
/* 003 [def:1801] [use:0001] */          ZN=--ram[0x02EB];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x681B);
/* 005 [def:0001] [use:0001] */      case 0x681E: L_681e: //D0 EB 20
/* 006 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x681E);
/* 009 [def:0001] [use:0001] */              PC = 0x680b;
/*                           */              clockticks += 22;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x681E);
/* 002 [def:0001] [use:0001] */      case 0x6820: L_6820: //20 FE 68
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x22;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6820);
/* 006 [def:0001] [use:0001] */          PC = 0x68fe;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6823: L_6823: //D0 E6 A2
/* 001 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6823);
/* 004 [def:0001] [use:0001] */              PC = 0x680b;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6823);
/* 002 [def:0001] [use:0001] */      case 0x6825: L_6825: //A2 01 8E
/* 003 [def:0001] [use:0001] */          X=0x01;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6825);
/* 006 [def:0001] [use:0001] */      case 0x6827: L_6827: //8E 19 02
/* 007 [def:0001] [use:0001] */          ram[0x0219] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6827);
/* 009 [def:0001] [use:0001] */      case 0x682A: L_682a: //86 8B A0
/* 010 [def:0001] [use:0001] */          ram[0x008B] = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x682A);
/* 012 [def:0001] [use:0001] */      case 0x682C: L_682c: //A0 47 4C
/* 013 [def:0021] [use:0000] */          Y=0x47;
/* 014 [def:1801] [use:0020] */          ZN = Y;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x682C);
/* 016 [def:0001] [use:0001] */      case 0x682E: L_682e: //4C 16 77
/* 017 [def:0001] [use:0001] */          //trace_PC(0x682E);
/* 018 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6831: L_6831: //AD 07 24
/* 001 [def:0009] [use:0001] */          A=ram[0x2407];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6831);
/* 004 [def:0001] [use:0001] */      case 0x6834: L_6834: //10 04 A9
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6834);
/* 008 [def:0001] [use:0001] */              PC = 0x683a;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6834);
/* 002 [def:0001] [use:0001] */      case 0x6836: L_6836: //A9 03 D0
/* 003 [def:0009] [use:0000] */          A=0x03;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6836);
/* 006 [def:0001] [use:0001] */      case 0x6838: L_6838: //D0 07 AD
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6838);
/* 010 [def:0001] [use:0001] */              PC = 0x6841;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6838);
/* 002 [def:0001] [use:0001] */      case 0x683A: L_683a: //AD 06 24
/* 003 [def:0009] [use:0001] */          A=ram[0x2406];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x683A);
/* 006 [def:0001] [use:0001] */      case 0x683D: L_683d: //10 07 A9
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x683D);
/* 010 [def:0001] [use:0001] */              PC = 0x6846;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x683D);
/* 002 [def:0001] [use:0001] */      case 0x683F: L_683f: //A9 FD 18
/* 003 [def:0009] [use:0000] */          A=0xFD;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x683F);
/* 006 [def:0001] [use:0001] */      case 0x6841: L_6841: //18 65 79
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6841);
/* 009 [def:0001] [use:0001] */      case 0x6842: L_6842: //65 79 85
/* 010 [def:b801] [use:6001] */          ADC(ram[0x0079]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6842);
/* 012 [def:0001] [use:0001] */      case 0x6844: L_6844: //85 79 A5
/* 013 [def:0001] [use:0008] */          ram[0x0079] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6844);
/* 015 [def:0001] [use:0001] */      case 0x6846: L_6846: //A5 76 4A
/* 016 [def:0009] [use:0001] */          A=ram[0x0076];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6846);
/* 019 [def:0001] [use:0001] */      case 0x6848: L_6848: //4A B0 C0
/* 020 [def:2001] [use:0008] */          C = A & 0x01;
/* 021 [def:0009] [use:0008] */          A = A >> 1;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6848);
/* 024 [def:0001] [use:0001] */      case 0x6849: L_6849: //B0 C0 AD
/* 025 [def:0001] [use:2001] */          if (C)
/* 026 [def:0001] [use:0001] */          {
/* 027 [def:0001] [use:0001] */              //trace_PC(0x6849);
/* 028 [def:0001] [use:0001] */              PC = 0x680b;
/*                           */              clockticks += 35;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6849);
/* 002 [def:0001] [use:0001] */      case 0x684B: L_684b: //AD 05 24
/* 003 [def:0009] [use:0001] */          A=ram[0x2405];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x684B);
/* 006 [def:0001] [use:0001] */      case 0x684E: L_684e: //10 35 A9
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x684E);
/* 010 [def:0001] [use:0001] */              PC = 0x6885;
/*                           */              clockticks += 41;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x684E);
/* 002 [def:0001] [use:0001] */      case 0x6850: L_6850: //A9 40 85
/* 003 [def:0009] [use:0000] */          A=0x40;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6850);
/* 006 [def:0001] [use:0001] */      case 0x6852: L_6852: //85 12 AD
/* 007 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6852);
/* 009 [def:0001] [use:0001] */      case 0x6854: L_6854: //AD 3A 02
/* 010 [def:0009] [use:0001] */          A=ram[0x023A];
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6854);
/* 013 [def:0001] [use:0001] */      case 0x6857: L_6857: //20 B6 68
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x59;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6857);
/* 017 [def:0001] [use:0001] */          PC = 0x68b6;
/*                           */          clockticks += 55; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x685A: L_685a: //65 7C AA
/* 001 [def:b801] [use:6001] */          ADC(ram[0x007C]);
/* 002 [def:0001] [use:0001] */          //trace_PC(0x685A);
/* 003 [def:0001] [use:0001] */      case 0x685C: L_685c: //AA A5 11
/* 004 [def:0011] [use:0008] */          X=A;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x685C);
/* 007 [def:0001] [use:0001] */      case 0x685D: L_685d: //A5 11 6D
/* 008 [def:0009] [use:0001] */          A=ram[0x0011];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x685D);
/* 011 [def:0001] [use:0001] */      case 0x685F: L_685f: //6D 3A 02
/* 012 [def:b801] [use:6001] */          ADC(ram[0x023A]);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x685F);
/* 014 [def:0001] [use:0001] */      case 0x6862: L_6862: //20 EA 68
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x64;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6862);
/* 018 [def:0001] [use:0001] */          PC = 0x68ea;
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6865: L_6865: //8D 3A 02
/* 001 [def:0001] [use:0008] */          ram[0x023A] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6865);
/* 003 [def:0001] [use:0001] */      case 0x6868: L_6868: //86 7C A9
/* 004 [def:0001] [use:0001] */          ram[0x007C] = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6868);
/* 006 [def:0001] [use:0001] */      case 0x686A: L_686a: //A9 00 85
/* 007 [def:0009] [use:0000] */          A=0x00;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x686A);
/* 010 [def:0001] [use:0001] */      case 0x686C: L_686c: //85 12 AD
/* 011 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x686C);
/* 013 [def:0001] [use:0001] */      case 0x686E: L_686e: //AD 5B 02
/* 014 [def:0009] [use:0001] */          A=ram[0x025B];
/* 015 [def:1801] [use:0008] */          ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x686E);
/* 017 [def:0001] [use:0001] */      case 0x6871: L_6871: //20 B6 68
/* 018 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x73;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6871);
/* 021 [def:0001] [use:0001] */          PC = 0x68b6;
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6874: L_6874: //65 7D AA
/* 001 [def:b801] [use:6001] */          ADC(ram[0x007D]);
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6874);
/* 003 [def:0001] [use:0001] */      case 0x6876: L_6876: //AA A5 11
/* 004 [def:0011] [use:0008] */          X=A;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6876);
/* 007 [def:0001] [use:0001] */      case 0x6877: L_6877: //A5 11 6D
/* 008 [def:0009] [use:0001] */          A=ram[0x0011];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6877);
/* 011 [def:0001] [use:0001] */      case 0x6879: L_6879: //6D 5B 02
/* 012 [def:b801] [use:6001] */          ADC(ram[0x025B]);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6879);
/* 014 [def:0001] [use:0001] */      case 0x687C: L_687c: //20 EA 68
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x7E;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x687C);
/* 018 [def:0001] [use:0001] */          PC = 0x68ea;
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x687F: L_687f: //8D 5B 02
/* 001 [def:0001] [use:0008] */          ram[0x025B] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x687F);
/* 003 [def:0001] [use:0001] */      case 0x6882: L_6882: //86 7D 60
/* 004 [def:0001] [use:0001] */          ram[0x007D] = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6882);
/* 006 [def:0001] [use:0001] */      case 0x6884: L_6884: //60 A9 00
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6884);
/* 008 [def:0001] [use:0001] */          PC=stack[++S];
/* 009 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 010 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6885: L_6885: //A9 00 AA
/* 001 [def:0009] [use:0000] */          A=0x00;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6885);
/* 004 [def:0001] [use:0001] */      case 0x6887: L_6887: //AA 38 ED
/* 005 [def:0011] [use:0008] */          X=A;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6887);
/* 008 [def:0001] [use:0001] */      case 0x6888: L_6888: //38 ED 3A
/* 009 [def:2001] [use:0000] */          C = 1;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6888);
/* 011 [def:0001] [use:0001] */      case 0x6889: L_6889: //ED 3A 02
/* 012 [def:b809] [use:6009] */          SBC(ram[0x023A]);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6889);
/* 014 [def:0001] [use:0001] */      case 0x688C: L_688c: //0A 0A 90
/* 015 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 016 [def:0009] [use:0008] */          A = A << 1;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x688C);
/* 019 [def:0001] [use:0001] */      case 0x688D: L_688d: //0A 90 02
/* 020 [def:2001] [use:0008] */          C = A & 0x80;
/* 021 [def:0009] [use:0008] */          A = A << 1;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x688D);
/* 024 [def:0001] [use:0001] */      case 0x688E: L_688e: //90 02 CA
/* 025 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 026 [def:0001] [use:0001] */          {
/* 027 [def:0001] [use:0001] */              //trace_PC(0x688E);
/* 028 [def:0001] [use:0001] */              PC = 0x6892;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x688E);
/* 002 [def:0001] [use:0001] */      case 0x6890: L_6890: //CA 18 65
/* 003 [def:0010] [use:0010] */  //      X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6890);
/* 006 [def:0001] [use:0001] */      case 0x6891: L_6891: //18 65 7C
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6891);
/* 009 [def:0001] [use:0001] */      case 0x6892: L_6892: //65 7C 85
/* 010 [def:b801] [use:6001] */          ADC(ram[0x007C]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6892);
/* 012 [def:0001] [use:0001] */      case 0x6894: L_6894: //85 7C 8A
/* 013 [def:0001] [use:0008] */          ram[0x007C] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6894);
/* 015 [def:0001] [use:0001] */      case 0x6896: L_6896: //8A 6D 3A
/* 016 [def:0001] [use:0001] */          A=X;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6896);
/* 019 [def:0001] [use:0001] */      case 0x6897: L_6897: //6D 3A 02
/* 020 [def:b801] [use:6001] */          ADC(ram[0x023A]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6897);
/* 022 [def:0001] [use:0001] */      case 0x689A: L_689a: //8D 3A 02
/* 023 [def:0001] [use:0008] */          ram[0x023A] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x689A);
/* 025 [def:0001] [use:0001] */      case 0x689D: L_689d: //A9 00 AA
/* 026 [def:0009] [use:0000] */          A=0x00;
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x689D);
/* 029 [def:0001] [use:0001] */      case 0x689F: L_689f: //AA 38 ED
/* 030 [def:0011] [use:0008] */          X=A;
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x689F);
/* 033 [def:0001] [use:0001] */      case 0x68A0: L_68a0: //38 ED 5B
/* 034 [def:2001] [use:0000] */          C = 1;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x68A0);
/* 036 [def:0001] [use:0001] */      case 0x68A1: L_68a1: //ED 5B 02
/* 037 [def:b809] [use:6009] */          SBC(ram[0x025B]);
/* 038 [def:0001] [use:0001] */          //trace_PC(0x68A1);
/* 039 [def:0001] [use:0001] */      case 0x68A4: L_68a4: //0A 0A 90
/* 040 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 041 [def:0009] [use:0008] */          A = A << 1;
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x68A4);
/* 044 [def:0001] [use:0001] */      case 0x68A5: L_68a5: //0A 90 02
/* 045 [def:2001] [use:0008] */          C = A & 0x80;
/* 046 [def:0009] [use:0008] */          A = A << 1;
/* 047 [def:1801] [use:0008] */          ZN = A;
/* 048 [def:0001] [use:0001] */          //trace_PC(0x68A5);
/* 049 [def:0001] [use:0001] */      case 0x68A6: L_68a6: //90 02 CA
/* 050 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 051 [def:0001] [use:0001] */          {
/* 052 [def:0001] [use:0001] */              //trace_PC(0x68A6);
/* 053 [def:0001] [use:0001] */              PC = 0x68aa;
/*                           */              clockticks += 54;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68A6);
/* 002 [def:0001] [use:0001] */      case 0x68A8: L_68a8: //CA 18 65
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x68A8);
/* 006 [def:0001] [use:0001] */      case 0x68A9: L_68a9: //18 65 7D
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x68A9);
/* 009 [def:0001] [use:0001] */      case 0x68AA: L_68aa: //65 7D 85
/* 010 [def:b801] [use:6001] */          ADC(ram[0x007D]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x68AA);
/* 012 [def:0001] [use:0001] */      case 0x68AC: L_68ac: //85 7D 8A
/* 013 [def:0001] [use:0008] */          ram[0x007D] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x68AC);
/* 015 [def:0001] [use:0001] */      case 0x68AE: L_68ae: //8A 6D 5B
/* 016 [def:0001] [use:0001] */          A=X;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x68AE);
/* 019 [def:0001] [use:0001] */      case 0x68AF: L_68af: //6D 5B 02
/* 020 [def:b801] [use:6001] */          ADC(ram[0x025B]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x68AF);
/* 022 [def:0001] [use:0001] */      case 0x68B2: L_68b2: //8D 5B 02
/* 023 [def:0001] [use:0008] */          ram[0x025B] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x68B2);
/* 025 [def:0001] [use:0001] */      case 0x68B5: L_68b5: //60 10 03
/* 026 [def:0001] [use:0001] */          //trace_PC(0x68B5);
/* 027 [def:0001] [use:0001] */          PC=stack[++S];
/* 028 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 029 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 78; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68B6: L_68b6: //10 03 20
/* 001 [def:0001] [use:1001] */          if (ZN < 0)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x68B6);
/* 004 [def:0001] [use:0001] */              PC = 0x68bb;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68B6);
/* 002 [def:0001] [use:0001] */      case 0x68B8: L_68b8: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xBA;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x68B8);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68BB: L_68bb: //4A 4A 4A
/* 001 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 002 [def:0009] [use:0008] */          A = A >> 1;
/* 003 [def:1800] [use:0008] */  //      ZN = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x68BB);
/* 005 [def:0001] [use:0001] */      case 0x68BC: L_68bc: //4A 4A AA
/* 006 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 007 [def:0009] [use:0008] */          A = A >> 1;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x68BC);
/* 010 [def:0001] [use:0001] */      case 0x68BD: L_68bd: //4A AA BD
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x68BD);
/* 015 [def:0001] [use:0001] */      case 0x68BE: L_68be: //AA BD E1
/* 016 [def:0011] [use:0008] */          X=A;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x68BE);
/* 019 [def:0001] [use:0001] */      case 0x68BF: L_68bf: //BD E1 68
/* 020 [def:0009] [use:0011] */          A=ram[0x68E1 + X /* can't wrap */];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x68BF);
/* 023 [def:0001] [use:0001] */      case 0x68C2: L_68c2: //24 73 10
/* 024 [def:1101] [use:0001] */          ZN=ram[0x0073];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 025 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 026 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 027 [def:0001] [use:0001] */          //trace_PC(0x68C2);
/* 028 [def:0001] [use:0001] */      case 0x68C4: L_68c4: //10 01 4A
/* 029 [def:0001] [use:1001] */          if (ZN < 0)
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x68C4);
/* 032 [def:0001] [use:0001] */              PC = 0x68c7;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68C4);
/* 002 [def:0001] [use:0001] */      case 0x68C6: L_68c6: //4A 85 11
/* 003 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 004 [def:0009] [use:0008] */          A = A >> 1;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x68C6);
/* 007 [def:0001] [use:0001] */      case 0x68C7: L_68c7: //85 11 A5
/* 008 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x68C7);
/* 010 [def:0001] [use:0001] */      case 0x68C9: L_68c9: //A5 79 18
/* 011 [def:0009] [use:0001] */          A=ram[0x0079];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x68C9);
/* 014 [def:0001] [use:0001] */      case 0x68CB: L_68cb: //18 65 12
/* 015 [def:2001] [use:0000] */          C = 0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x68CB);
/* 017 [def:0001] [use:0001] */      case 0x68CC: L_68cc: //65 12 20
/* 018 [def:b801] [use:6001] */          ADC(ram[0x0012]);
/* 019 [def:0001] [use:0001] */          //trace_PC(0x68CC);
/* 020 [def:0001] [use:0001] */      case 0x68CE: L_68ce: //20 01 71
/* 021 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 022 [def:0001] [use:0001] */          stack[S--] = 0xD0;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x68CE);
/* 024 [def:0001] [use:0001] */          PC = 0x7101;
/*                           */          clockticks += 35; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68D1: L_68d1: //20 BB 49
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x68;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xD3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x68D1);
/* 004 [def:0001] [use:0001] */          PC = 0x49bb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68D4: L_68d4: //A0 00 0A
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x68D4);
/* 004 [def:0001] [use:0001] */      case 0x68D6: L_68d6: //0A 90 01
/* 005 [def:2001] [use:0008] */          C = A & 0x80;
/* 006 [def:0009] [use:0008] */          A = A << 1;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x68D6);
/* 009 [def:0001] [use:0001] */      case 0x68D7: L_68d7: //90 01 88
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x68D7);
/* 013 [def:0001] [use:0001] */              PC = 0x68da;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68D7);
/* 002 [def:0001] [use:0001] */      case 0x68D9: L_68d9: //88 0A 84
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x68D9);
/* 006 [def:0001] [use:0001] */      case 0x68DA: L_68da: //0A 84 11
/* 007 [def:2001] [use:0008] */          C = A & 0x80;
/* 008 [def:0009] [use:0008] */          A = A << 1;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x68DA);
/* 011 [def:0001] [use:0001] */      case 0x68DB: L_68db: //84 11 26
/* 012 [def:0001] [use:0020] */          ram[0x0011] = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x68DB);
/* 014 [def:0001] [use:0001] */      case 0x68DD: L_68dd: //26 11 18
/* 015 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 016 [def:0101] [use:0001] */          ZN=ram[0x0011];
/* 017 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 018 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 019 [def:1801] [use:10100] */          ZN |= saveflags;
/* 020 [def:0001] [use:1800] */          ram[0x0011] = ZN;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x68DD);
/* 022 [def:0001] [use:0001] */      case 0x68DF: L_68df: //18 60 80
/* 023 [def:2001] [use:0000] */          C = 0;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x68DF);
/* 025 [def:0001] [use:0001] */      case 0x68E0: L_68e0: //60 80 70
/* 026 [def:0001] [use:0001] */          //trace_PC(0x68E0);
/* 027 [def:0001] [use:0001] */          PC=stack[++S];
/* 028 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 029 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 26; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68EA: L_68ea: //30 09 C9
/* 001 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x68EA);
/* 004 [def:0001] [use:0001] */              PC = 0x68f5;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68EA);
/* 002 [def:0001] [use:0001] */      case 0x68EC: L_68ec: //C9 40 90
/* 003 [def:0101] [use:0000] */          ZN=0x40;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x68EC);
/* 007 [def:0001] [use:0001] */      case 0x68EE: L_68ee: //90 0D A2
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x68EE);
/* 011 [def:0001] [use:0001] */              PC = 0x68fd;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68EE);
/* 002 [def:0001] [use:0001] */      case 0x68F5: L_68f5: //C9 C1 B0
/* 003 [def:0101] [use:0000] */          ZN=0xC1;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x68F5);
/* 007 [def:0001] [use:0001] */      case 0x68F7: L_68f7: //B0 04 A2
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x68F7);
/* 011 [def:0001] [use:0001] */              PC = 0x68fd;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x68F7);
/* 002 [def:0001] [use:0001] */      case 0x68FD: L_68fd: //60 A5 76
/* 003 [def:0001] [use:0001] */          //trace_PC(0x68FD);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x68FE: L_68fe: //A5 76 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0076];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x68FE);
/* 004 [def:0001] [use:0001] */      case 0x6900: L_6900: //29 03 D0
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6900);
/* 008 [def:0001] [use:0001] */      case 0x6902: L_6902: //D0 25 E6
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6902);
/* 012 [def:0001] [use:0001] */              PC = 0x6929;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6902);
/* 002 [def:0001] [use:0001] */      case 0x6904: L_6904: //E6 DE D0
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x00DE];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6904);
/* 005 [def:0001] [use:0001] */      case 0x6906: L_6906: //D0 21 A9
/* 006 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6906);
/* 009 [def:0001] [use:0001] */              PC = 0x6929;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6906);
/* 002 [def:0001] [use:0001] */      case 0x6929: L_6929: //A2 18 BD
/* 003 [def:0001] [use:0001] */          X=0x18;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6929);
/* 006 [def:0001] [use:0001] */      case 0x692B: L_692b: //BD 00 02
/* 007 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x692B);
/* 010 [def:0001] [use:0001] */      case 0x692E: L_692e: //F0 1E BD
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x692E);
/* 014 [def:0001] [use:0001] */              PC = 0x694e;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x692E);
/* 002 [def:0001] [use:0001] */      case 0x6930: L_6930: //BD 63 02
/* 003 [def:0009] [use:0011] */          A=ram[0x0263 + X /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6930);
/* 006 [def:0001] [use:0001] */      case 0x6933: L_6933: //38 ED 7C
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6933);
/* 009 [def:0001] [use:0001] */      case 0x6934: L_6934: //ED 7C 02
/* 010 [def:b809] [use:6009] */          SBC(ram[0x027C]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6934);
/* 012 [def:0001] [use:0001] */      case 0x6937: L_6937: //C9 05 90
/* 013 [def:0101] [use:0000] */          ZN=0x05;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6937);
/* 017 [def:0001] [use:0001] */      case 0x6939: L_6939: //90 04 C9
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x6939);
/* 021 [def:0001] [use:0001] */              PC = 0x693f;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6939);
/* 002 [def:0001] [use:0001] */      case 0x693B: L_693b: //C9 FB 90
/* 003 [def:0101] [use:0000] */          ZN=0xFB;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x693B);
/* 007 [def:0001] [use:0001] */      case 0x693D: L_693d: //90 0F BD
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x693D);
/* 011 [def:0001] [use:0001] */              PC = 0x694e;
/*                           */              clockticks += 45;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x693D);
/* 002 [def:0001] [use:0001] */      case 0x693F: L_693f: //BD 84 02
/* 003 [def:0009] [use:0011] */          A=ram[0x0284 + X /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x693F);
/* 006 [def:0001] [use:0001] */      case 0x6942: L_6942: //38 ED 9D
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6942);
/* 009 [def:0001] [use:0001] */      case 0x6943: L_6943: //ED 9D 02
/* 010 [def:b809] [use:6009] */          SBC(ram[0x029D]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6943);
/* 012 [def:0001] [use:0001] */      case 0x6946: L_6946: //C9 05 90
/* 013 [def:0101] [use:0000] */          ZN=0x05;
/* 014 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 015 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6946);
/* 017 [def:0001] [use:0001] */      case 0x6948: L_6948: //90 09 C9
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x6948);
/* 021 [def:0001] [use:0001] */              PC = 0x6953;
/*                           */              clockticks += 60;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6948);
/* 002 [def:0001] [use:0001] */      case 0x694A: L_694a: //C9 FB B0
/* 003 [def:0101] [use:0000] */          ZN=0xFB;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x694A);
/* 007 [def:0001] [use:0001] */      case 0x694C: L_694c: //B0 05 CA
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x694C);
/* 011 [def:0001] [use:0001] */              PC = 0x6953;
/*                           */              clockticks += 65;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x694C);
/* 002 [def:0001] [use:0001] */      case 0x694E: L_694e: //CA 10 DA
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x694E);
/* 006 [def:0001] [use:0001] */      case 0x694F: L_694f: //10 DA E8
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x694F);
/* 010 [def:0001] [use:0001] */              PC = 0x692b;
/*                           */              clockticks += 69;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x694F);
/* 002 [def:0001] [use:0001] */      case 0x6951: L_6951: //E8 60 EE
/* 003 [def:0011] [use:0010] */          X++;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6951);
/* 006 [def:0001] [use:0001] */      case 0x6952: L_6952: //60 EE EB
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6952);
/* 008 [def:0001] [use:0001] */          PC=stack[++S];
/* 009 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 010 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 76; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6953: L_6953: //EE EB 02
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x02EB];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6953);
/* 003 [def:0001] [use:0001] */      case 0x6956: L_6956: //60 1C 10
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6956);
/* 005 [def:0001] [use:0001] */          PC=stack[++S];
/* 006 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 007 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6959: L_6959: //A2 18 AD
/* 001 [def:0001] [use:0001] */          X=0x18;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6959);
/* 004 [def:0001] [use:0001] */      case 0x695B: L_695b: //AD EC 02
/* 005 [def:0009] [use:0001] */          A=ram[0x02EC];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x695B);
/* 008 [def:0001] [use:0001] */      case 0x695E: L_695e: //F0 03 4C
/* 009 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x695E);
/* 012 [def:0001] [use:0001] */              PC = 0x6963;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x695E);
/* 002 [def:0001] [use:0001] */      case 0x6960: L_6960: //4C DE 69
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6960);
/* 004 [def:0001] [use:0001] */          PC = 0x69de;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6963: L_6963: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6963);
/* 004 [def:0001] [use:0001] */      case 0x6965: L_6965: //F0 07 AD
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6965);
/* 008 [def:0001] [use:0001] */              PC = 0x696e;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6965);
/* 002 [def:0001] [use:0001] */      case 0x6967: L_6967: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6967);
/* 006 [def:0001] [use:0001] */      case 0x696A: L_696a: //F0 EA 30
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x696A);
/* 010 [def:0001] [use:0001] */              PC = 0x6956;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x696A);
/* 002 [def:0001] [use:0001] */      case 0x696C: L_696c: //30 E8 AD
/* 003 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x696C);
/* 006 [def:0001] [use:0001] */              PC = 0x6956;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x696C);
/* 002 [def:0001] [use:0001] */      case 0x696E: L_696e: //AD 1A 02
/* 003 [def:0009] [use:0001] */          A=ram[0x021A];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x696E);
/* 006 [def:0001] [use:0001] */      case 0x6971: L_6971: //D0 E3 8D
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6971);
/* 010 [def:0001] [use:0001] */              PC = 0x6956;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6971);
/* 002 [def:0001] [use:0001] */      case 0x6973: L_6973: //8D FF 02
/* 003 [def:0001] [use:0008] */          ram[0x02FF] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6973);
/* 005 [def:0001] [use:0001] */      case 0x6976: L_6976: //A6 1E 95
/* 006 [def:0001] [use:0001] */          X=ram[0x001E];
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6976);
/* 009 [def:0001] [use:0001] */      case 0x6978: L_6978: //95 D1 A2
/* 010 [def:0001] [use:0019] */          ram[(unsigned char)(0xd1 + X)] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6978);
/* 012 [def:0001] [use:0001] */      case 0x697A: L_697a: //A2 06 9D
/* 013 [def:0001] [use:0001] */          X=0x06;
/* 014 [def:1800] [use:0010] */  //      ZN = X;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x697A);
/* 016 [def:0001] [use:0001] */      case 0x697C: L_697c: //9D F8 02
/* 017 [def:0001] [use:0019] */          ram[0x02F8 + X /* can't wrap */] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x697C);
/* 019 [def:0001] [use:0001] */      case 0x697F: L_697f: //CA 10 FA
/* 020 [def:0011] [use:0010] */          X--;
/* 021 [def:1801] [use:0010] */          ZN = X;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x697F);
/* 023 [def:0001] [use:0001] */      case 0x6980: L_6980: //10 FA AD
/* 024 [def:0001] [use:1001] */          if (ZN < 0)
/* 025 [def:0001] [use:0001] */          {
/* 026 [def:0001] [use:0001] */              //trace_PC(0x6980);
/* 027 [def:0001] [use:0001] */              PC = 0x697c;
/*                           */              clockticks += 43;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6980);
/* 002 [def:0001] [use:0001] */      case 0x6982: L_6982: //AD 01 28
/* 003 [def:0009] [use:0001] */          A=ram[0x2801];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6982);
/* 006 [def:0001] [use:0001] */      case 0x6985: L_6985: //29 02 09
/* 007 [def:0009] [use:0008] */          A &= 0x02;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6985);
/* 010 [def:0001] [use:0001] */      case 0x6987: L_6987: //09 04 18
/* 011 [def:0001] [use:0001] */          A |= 0x04;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6987);
/* 014 [def:0001] [use:0001] */      case 0x6989: L_6989: //18 6D F0
/* 015 [def:2001] [use:0000] */          C = 0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6989);
/* 017 [def:0001] [use:0001] */      case 0x698A: L_698a: //6D F0 02
/* 018 [def:b801] [use:6001] */          ADC(ram[0x02F0]);
/* 019 [def:0001] [use:0001] */          //trace_PC(0x698A);
/* 020 [def:0001] [use:0001] */      case 0x698D: L_698d: //A8 C9 0A
/* 021 [def:0021] [use:0008] */          Y=A;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x698D);
/* 024 [def:0001] [use:0001] */      case 0x698E: L_698e: //C9 0A 90
/* 025 [def:0101] [use:0000] */          ZN=0x0A;
/* 026 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 027 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x698E);
/* 029 [def:0001] [use:0001] */      case 0x6990: L_6990: //90 02 A9
/* 030 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 031 [def:0001] [use:0001] */          {
/* 032 [def:0001] [use:0001] */              //trace_PC(0x6990);
/* 033 [def:0001] [use:0001] */              PC = 0x6994;
/*                           */              clockticks += 66;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6990);
/* 002 [def:0001] [use:0001] */      case 0x6994: L_6994: //85 D9 20
/* 003 [def:0001] [use:0008] */          ram[0x00D9] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6994);
/* 005 [def:0001] [use:0001] */      case 0x6996: L_6996: //20 B6 70
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x69;
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x98;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6996);
/* 009 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 73; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6999: L_6999: //85 DB 18
/* 001 [def:0001] [use:0008] */          ram[0x00DB] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6999);
/* 003 [def:0001] [use:0001] */      case 0x699B: L_699b: //18 69 EB
/* 004 [def:2001] [use:0000] */          C = 0;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x699B);
/* 006 [def:0001] [use:0001] */      case 0x699C: L_699c: //69 EB 85
/* 007 [def:b801] [use:6001] */          ADC(0xEB);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x699C);
/* 009 [def:0001] [use:0001] */      case 0x699E: L_699e: //85 DC 20
/* 010 [def:0001] [use:0008] */          ram[0x00DC] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x699E);
/* 012 [def:0001] [use:0001] */      case 0x69A0: L_69a0: //20 B6 70
/* 013 [def:0001] [use:0001] */          stack[S--] = 0x69;
/* 014 [def:0001] [use:0001] */          stack[S--] = 0xA2;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x69A0);
/* 016 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 15; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x69A3: L_69a3: //85 DA C0
/* 001 [def:0001] [use:0008] */          ram[0x00DA] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x69A3);
/* 003 [def:0001] [use:0001] */      case 0x69A5: L_69a5: //C0 3F 90
/* 004 [def:0101] [use:0001] */          ZN=0x3F;
/* 005 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 006 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x69A5);
/* 008 [def:0001] [use:0001] */      case 0x69A7: L_69a7: //90 07 A5
/* 009 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x69A7);
/* 012 [def:0001] [use:0001] */              PC = 0x69b0;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69A7);
/* 002 [def:0001] [use:0001] */      case 0x69B0: L_69b0: //EE F0 02
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x02F0];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x69B0);
/* 005 [def:0001] [use:0001] */      case 0x69B3: L_69b3: //C0 09 90
/* 006 [def:0101] [use:0001] */          ZN=0x09;
/* 007 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 008 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x69B3);
/* 010 [def:0001] [use:0001] */      case 0x69B5: L_69b5: //90 02 A0
/* 011 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x69B5);
/* 014 [def:0001] [use:0001] */              PC = 0x69b9;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69B5);
/* 002 [def:0001] [use:0001] */      case 0x69B9: L_69b9: //8C E7 02
/* 003 [def:0001] [use:0001] */          ram[0x02E7] = Y;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x69B9);
/* 005 [def:0001] [use:0001] */      case 0x69BC: L_69bc: //84 09 A2
/* 006 [def:0001] [use:0020] */          ram[0x0009] = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x69BC);
/* 008 [def:0001] [use:0001] */      case 0x69BE: L_69be: //A2 18 AD
/* 009 [def:0001] [use:0001] */          X=0x18;
/* 010 [def:1800] [use:0010] */  //      ZN = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x69BE);
/* 012 [def:0001] [use:0001] */      case 0x69C0: L_69c0: //AD EE 02
/* 013 [def:0009] [use:0001] */          A=ram[0x02EE];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x69C0);
/* 016 [def:0001] [use:0001] */      case 0x69C3: L_69c3: //C9 0A B0
/* 017 [def:0101] [use:0000] */          ZN=0x0A;
/* 018 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 019 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x69C3);
/* 021 [def:0001] [use:0001] */      case 0x69C5: L_69c5: //B0 03 EE
/* 022 [def:0001] [use:2001] */          if (C)
/* 023 [def:0001] [use:0001] */          {
/* 024 [def:0001] [use:0001] */              //trace_PC(0x69C5);
/* 025 [def:0001] [use:0001] */              PC = 0x69ca;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69C5);
/* 002 [def:0001] [use:0001] */      case 0x69C7: L_69c7: //EE EE 02
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x02EE];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x69C7);
/* 005 [def:0001] [use:0001] */      case 0x69CA: L_69ca: //A0 1A 20
/* 006 [def:0021] [use:0000] */          Y=0x1A;
/* 007 [def:1801] [use:0020] */          ZN = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x69CA);
/* 009 [def:0001] [use:0001] */      case 0x69CC: L_69cc: //20 E7 69
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x69;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0xCE;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x69CC);
/* 013 [def:0001] [use:0001] */          PC = 0x69e7;
/*                           */          clockticks += 51; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x69CF: L_69cf: //CA C6 09
/* 001 [def:0011] [use:0010] */          X--;
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x69CF);
/* 004 [def:0001] [use:0001] */      case 0x69D0: L_69d0: //C6 09 D0
/* 005 [def:0001] [use:0001] */          ZN=ram[0x0009]-1;
/* 006 [def:0001] [use:0001] */          ram[0x0009] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x69D0);
/* 008 [def:0001] [use:0001] */      case 0x69D2: L_69d2: //D0 F8 A9
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x69D2);
/* 012 [def:0001] [use:0001] */              PC = 0x69cc;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69D2);
/* 002 [def:0001] [use:0001] */      case 0x69D4: L_69d4: //A9 7F 8D
/* 003 [def:0009] [use:0000] */          A=0x7F;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x69D4);
/* 006 [def:0001] [use:0001] */      case 0x69D6: L_69d6: //8D E8 02
/* 007 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x69D6);
/* 009 [def:0001] [use:0001] */      case 0x69D9: L_69d9: //A9 30 8D
/* 010 [def:0009] [use:0000] */          A=0x30;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x69D9);
/* 013 [def:0001] [use:0001] */      case 0x69DB: L_69db: //8D ED 02
/* 014 [def:0001] [use:0008] */          ram[0x02ED] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x69DB);
/* 016 [def:0001] [use:0001] */      case 0x69DE: L_69de: //A9 00 9D
/* 017 [def:0009] [use:0000] */          A=0x00;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x69DE);
/* 020 [def:0001] [use:0001] */      case 0x69E0: L_69e0: //9D 00 02
/* 021 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x69E0);
/* 023 [def:0001] [use:0001] */      case 0x69E3: L_69e3: //CA 10 FA
/* 024 [def:0011] [use:0010] */          X--;
/* 025 [def:1801] [use:0010] */          ZN = X;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x69E3);
/* 027 [def:0001] [use:0001] */      case 0x69E4: L_69e4: //10 FA 60
/* 028 [def:0001] [use:1001] */          if (ZN < 0)
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x69E4);
/* 031 [def:0001] [use:0001] */              PC = 0x69e0;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69E4);
/* 002 [def:0001] [use:0001] */      case 0x69E6: L_69e6: //60 AD 0A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x69E6);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 41; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x69E7: L_69e7: //AD 0A 2C
/* 001 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x69E7);
/* 004 [def:0001] [use:0001] */      case 0x69EA: L_69ea: //29 38 09
/* 005 [def:0009] [use:0008] */          A &= 0x38;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x69EA);
/* 008 [def:0001] [use:0001] */      case 0x69EC: L_69ec: //09 04 9D
/* 009 [def:0001] [use:0001] */          A |= 0x04;
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x69EC);
/* 012 [def:0001] [use:0001] */      case 0x69EE: L_69ee: //9D 00 02
/* 013 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x69EE);
/* 015 [def:0001] [use:0001] */      case 0x69F1: L_69f1: //20 3B 6A
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x69;
/* 017 [def:0001] [use:0001] */          stack[S--] = 0xF3;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x69F1);
/* 019 [def:0001] [use:0001] */          PC = 0x6a3b;
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x69F4: L_69f4: //AD 0A 2C
/* 001 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x69F4);
/* 004 [def:0001] [use:0001] */      case 0x69F7: L_69f7: //4A 29 1F
/* 005 [def:2001] [use:0008] */          C = A & 0x01;
/* 006 [def:0009] [use:0008] */          A = A >> 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x69F7);
/* 009 [def:0001] [use:0001] */      case 0x69F8: L_69f8: //29 1F 90
/* 010 [def:0009] [use:0008] */          A &= 0x1F;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x69F8);
/* 013 [def:0001] [use:0001] */      case 0x69FA: L_69fa: //90 13 C9
/* 014 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x69FA);
/* 017 [def:0001] [use:0001] */              PC = 0x6a0f;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69FA);
/* 002 [def:0001] [use:0001] */      case 0x69FC: L_69fc: //C9 18 90
/* 003 [def:0101] [use:0000] */          ZN=0x18;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x69FC);
/* 007 [def:0001] [use:0001] */      case 0x69FE: L_69fe: //90 02 29
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x69FE);
/* 011 [def:0001] [use:0001] */              PC = 0x6a02;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x69FE);
/* 002 [def:0001] [use:0001] */      case 0x6A00: L_6a00: //29 17 9D
/* 003 [def:0009] [use:0008] */          A &= 0x17;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A00);
/* 006 [def:0001] [use:0001] */      case 0x6A02: L_6a02: //9D 84 02
/* 007 [def:0001] [use:0019] */          ram[0x0284 + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6A02);
/* 009 [def:0001] [use:0001] */      case 0x6A05: L_6a05: //A9 00 9D
/* 010 [def:0009] [use:0000] */          A=0x00;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6A05);
/* 013 [def:0001] [use:0001] */      case 0x6A07: L_6a07: //9D 63 02
/* 014 [def:0001] [use:0019] */          ram[0x0263 + X /* can't wrap */] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6A07);
/* 016 [def:0001] [use:0001] */      case 0x6A0A: L_6a0a: //9D A5 02
/* 017 [def:0001] [use:0019] */          ram[0x02A5 + X /* can't wrap */] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6A0A);
/* 019 [def:0001] [use:0001] */      case 0x6A0D: L_6a0d: //F0 0B 9D
/* 020 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x6A0D);
/* 023 [def:0001] [use:0001] */              PC = 0x6a1a;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A0D);
/* 002 [def:0001] [use:0001] */      case 0x6A0F: L_6a0f: //9D 63 02
/* 003 [def:0001] [use:0019] */          ram[0x0263 + X /* can't wrap */] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6A0F);
/* 005 [def:0001] [use:0001] */      case 0x6A12: L_6a12: //A9 00 9D
/* 006 [def:0009] [use:0000] */          A=0x00;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6A12);
/* 009 [def:0001] [use:0001] */      case 0x6A14: L_6a14: //9D 84 02
/* 010 [def:0001] [use:0019] */          ram[0x0284 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6A14);
/* 012 [def:0001] [use:0001] */      case 0x6A17: L_6a17: //9D C6 02
/* 013 [def:0001] [use:0019] */          ram[0x02C6 + X /* can't wrap */] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6A17);
/* 015 [def:0001] [use:0001] */      case 0x6A1A: L_6a1a: //60 A9 60
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6A1A);
/* 017 [def:0001] [use:0001] */          PC=stack[++S];
/* 018 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 019 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 63; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A1B: L_6a1b: //A9 60 8D
/* 001 [def:0009] [use:0000] */          A=0x60;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A1B);
/* 004 [def:0001] [use:0001] */      case 0x6A1D: L_6a1d: //8D BE 02
/* 005 [def:0001] [use:0008] */          ram[0x02BE] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6A1D);
/* 007 [def:0001] [use:0001] */      case 0x6A20: L_6a20: //8D DF 02
/* 008 [def:0001] [use:0008] */          ram[0x02DF] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6A20);
/* 010 [def:0001] [use:0001] */      case 0x6A23: L_6a23: //A9 00 8D
/* 011 [def:0009] [use:0000] */          A=0x00;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6A23);
/* 014 [def:0001] [use:0001] */      case 0x6A25: L_6a25: //8D 3A 02
/* 015 [def:0001] [use:0008] */          ram[0x023A] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6A25);
/* 017 [def:0001] [use:0001] */      case 0x6A28: L_6a28: //8D 5B 02
/* 018 [def:0001] [use:0008] */          ram[0x025B] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6A28);
/* 020 [def:0001] [use:0001] */      case 0x6A2B: L_6a2b: //A9 10 8D
/* 021 [def:0009] [use:0000] */          A=0x10;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6A2B);
/* 024 [def:0001] [use:0001] */      case 0x6A2D: L_6a2d: //8D 7C 02
/* 025 [def:0001] [use:0008] */          ram[0x027C] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6A2D);
/* 027 [def:0001] [use:0001] */      case 0x6A30: L_6a30: //A9 0C 8D
/* 028 [def:0009] [use:0000] */          A=0x0C;
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6A30);
/* 031 [def:0001] [use:0001] */      case 0x6A32: L_6a32: //8D 9D 02
/* 032 [def:0001] [use:0008] */          ram[0x029D] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6A32);
/* 034 [def:0001] [use:0001] */      case 0x6A35: L_6a35: //A9 FF 8D
/* 035 [def:0009] [use:0000] */          A=0xFF;
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x6A35);
/* 038 [def:0001] [use:0001] */      case 0x6A37: L_6a37: //8D EF 02
/* 039 [def:0001] [use:0008] */          ram[0x02EF] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6A37);
/* 041 [def:0001] [use:0001] */      case 0x6A3A: L_6a3a: //60 AD 0A
/* 042 [def:0001] [use:0001] */          //trace_PC(0x6A3A);
/* 043 [def:0001] [use:0001] */          PC=stack[++S];
/* 044 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 045 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 49; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A3B: L_6a3b: //AD 0A 2C
/* 001 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A3B);
/* 004 [def:0001] [use:0001] */      case 0x6A3E: L_6a3e: //29 8F 10
/* 005 [def:0009] [use:0008] */          A &= 0x8F;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6A3E);
/* 008 [def:0001] [use:0001] */      case 0x6A40: L_6a40: //10 02 09
/* 009 [def:0001] [use:1001] */          if (ZN < 0)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6A40);
/* 012 [def:0001] [use:0001] */              PC = 0x6a44;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A40);
/* 002 [def:0001] [use:0001] */      case 0x6A42: L_6a42: //09 F0 18
/* 003 [def:0001] [use:0001] */          A |= 0xF0;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A42);
/* 006 [def:0001] [use:0001] */      case 0x6A44: L_6a44: //18 79 21
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6A44);
/* 009 [def:0001] [use:0001] */      case 0x6A45: L_6a45: //79 21 02
/* 010 [def:b801] [use:6021] */          ADC(ram[(unsigned short)(0x0221 + Y)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6A45);
/* 012 [def:0001] [use:0001] */      case 0x6A48: L_6a48: //20 62 6A
/* 013 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x4A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6A48);
/* 016 [def:0001] [use:0001] */          PC = 0x6a62;
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A4B: L_6a4b: //9D 21 02
/* 001 [def:0001] [use:0019] */          ram[0x0221 + X /* can't wrap */] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6A4B);
/* 003 [def:0001] [use:0001] */      case 0x6A4E: L_6a4e: //AD 0A 2C
/* 004 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6A4E);
/* 007 [def:0001] [use:0001] */      case 0x6A51: L_6a51: //29 8F 10
/* 008 [def:0009] [use:0008] */          A &= 0x8F;
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6A51);
/* 011 [def:0001] [use:0001] */      case 0x6A53: L_6a53: //10 02 09
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6A53);
/* 015 [def:0001] [use:0001] */              PC = 0x6a57;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A53);
/* 002 [def:0001] [use:0001] */      case 0x6A55: L_6a55: //09 F0 18
/* 003 [def:0001] [use:0001] */          A |= 0xF0;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A55);
/* 006 [def:0001] [use:0001] */      case 0x6A57: L_6a57: //18 79 42
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6A57);
/* 009 [def:0001] [use:0001] */      case 0x6A58: L_6a58: //79 42 02
/* 010 [def:b801] [use:6021] */          ADC(ram[(unsigned short)(0x0242 + Y)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6A58);
/* 012 [def:0001] [use:0001] */      case 0x6A5B: L_6a5b: //20 62 6A
/* 013 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x5D;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6A5B);
/* 016 [def:0001] [use:0001] */          PC = 0x6a62;
/*                           */          clockticks += 29; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A5E: L_6a5e: //9D 42 02
/* 001 [def:0001] [use:0019] */          ram[0x0242 + X /* can't wrap */] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6A5E);
/* 003 [def:0001] [use:0001] */      case 0x6A61: L_6a61: //60 10 0D
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6A61);
/* 005 [def:0001] [use:0001] */          PC=stack[++S];
/* 006 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 007 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A62: L_6a62: //10 0D C5
/* 001 [def:0001] [use:1001] */          if (ZN < 0)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6A62);
/* 004 [def:0001] [use:0001] */              PC = 0x6a71;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A62);
/* 002 [def:0001] [use:0001] */      case 0x6A64: L_6a64: //C5 DC B0
/* 003 [def:0001] [use:0001] */          ZN=ram[0x00DC];
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6A64);
/* 007 [def:0001] [use:0001] */      case 0x6A66: L_6a66: //B0 02 A5
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6A66);
/* 011 [def:0001] [use:0001] */              PC = 0x6a6a;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A66);
/* 002 [def:0001] [use:0001] */      case 0x6A68: L_6a68: //A5 DC C5
/* 003 [def:0009] [use:0001] */          A=ram[0x00DC];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A68);
/* 006 [def:0001] [use:0001] */      case 0x6A6A: L_6a6a: //C5 DB 90
/* 007 [def:0001] [use:0001] */          ZN=ram[0x00DB];
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6A6A);
/* 011 [def:0001] [use:0001] */      case 0x6A6C: L_6a6c: //90 0F A5
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6A6C);
/* 015 [def:0001] [use:0001] */              PC = 0x6a7d;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A6C);
/* 002 [def:0001] [use:0001] */      case 0x6A6E: L_6a6e: //A5 DB 60
/* 003 [def:0009] [use:0001] */          A=ram[0x00DB];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A6E);
/* 006 [def:0001] [use:0001] */      case 0x6A70: L_6a70: //60 C5 D9
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6A70);
/* 008 [def:0001] [use:0001] */          PC=stack[++S];
/* 009 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 010 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A71: L_6a71: //C5 D9 B0
/* 001 [def:0001] [use:0001] */          ZN=ram[0x00D9];
/* 002 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 003 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6A71);
/* 005 [def:0001] [use:0001] */      case 0x6A73: L_6a73: //B0 02 A5
/* 006 [def:0001] [use:2001] */          if (C)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6A73);
/* 009 [def:0001] [use:0001] */              PC = 0x6a77;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A73);
/* 002 [def:0001] [use:0001] */      case 0x6A75: L_6a75: //A5 D9 C5
/* 003 [def:0009] [use:0001] */          A=ram[0x00D9];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A75);
/* 006 [def:0001] [use:0001] */      case 0x6A77: L_6a77: //C5 DA 90
/* 007 [def:0001] [use:0001] */          ZN=ram[0x00DA];
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6A77);
/* 011 [def:0001] [use:0001] */      case 0x6A79: L_6a79: //90 02 A5
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x6A79);
/* 015 [def:0001] [use:0001] */              PC = 0x6a7d;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A79);
/* 002 [def:0001] [use:0001] */      case 0x6A7B: L_6a7b: //A5 DA 60
/* 003 [def:0009] [use:0001] */          A=ram[0x00DA];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A7B);
/* 006 [def:0001] [use:0001] */      case 0x6A7D: L_6a7d: //60 A5 22
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6A7D);
/* 008 [def:0001] [use:0001] */          PC=stack[++S];
/* 009 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 010 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A7E: L_6a7e: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A7E);
/* 004 [def:0001] [use:0001] */      case 0x6A80: L_6a80: //F0 0D A9
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6A80);
/* 008 [def:0001] [use:0001] */              PC = 0x6a8f;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A80);
/* 002 [def:0001] [use:0001] */      case 0x6A82: L_6a82: //A9 81 A2
/* 003 [def:0009] [use:0000] */          A=0x81;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A82);
/* 006 [def:0001] [use:0001] */      case 0x6A84: L_6a84: //A2 C3 20
/* 007 [def:0001] [use:0001] */          X=0xC3;
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6A84);
/* 010 [def:0001] [use:0001] */      case 0x6A86: L_6a86: //20 D5 7C
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x88;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6A86);
/* 014 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A89: L_6a89: //A0 00 A5
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A89);
/* 004 [def:0001] [use:0001] */      case 0x6A8B: L_6a8b: //A5 1E D0
/* 005 [def:0009] [use:0001] */          A=ram[0x001E];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6A8B);
/* 008 [def:0001] [use:0001] */      case 0x6A8D: L_6a8d: //D0 02 A0
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6A8D);
/* 012 [def:0001] [use:0001] */              PC = 0x6a91;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6A8D);
/* 002 [def:0001] [use:0001] */      case 0x6A8F: L_6a8f: //A0 10 84
/* 003 [def:0021] [use:0000] */          Y=0x10;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6A8F);
/* 006 [def:0001] [use:0001] */      case 0x6A91: L_6a91: //84 01 A9
/* 007 [def:0001] [use:0020] */          ram[0x0001] = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6A91);
/* 009 [def:0001] [use:0001] */      case 0x6A93: L_6a93: //A9 19 A2
/* 010 [def:0009] [use:0000] */          A=0x19;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6A93);
/* 013 [def:0001] [use:0001] */      case 0x6A95: L_6a95: //A2 DB 20
/* 014 [def:0001] [use:0001] */          X=0xDB;
/* 015 [def:1801] [use:0010] */          ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6A95);
/* 017 [def:0001] [use:0001] */      case 0x6A97: L_6a97: //20 1F 7A
/* 018 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x99;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6A97);
/* 021 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 25; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A9A: L_6a9a: //A9 70 20
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A9A);
/* 004 [def:0001] [use:0001] */      case 0x6A9C: L_6a9c: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x9E;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6A9C);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6A9F: L_6a9f: //A5 22 C9
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6A9F);
/* 004 [def:0001] [use:0001] */      case 0x6AA1: L_6aa1: //C9 02 90
/* 005 [def:0101] [use:0000] */          ZN=0x02;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6AA1);
/* 009 [def:0001] [use:0001] */      case 0x6AA3: L_6aa3: //90 14 A5
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6AA3);
/* 013 [def:0001] [use:0001] */              PC = 0x6ab9;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6AA3);
/* 002 [def:0001] [use:0001] */      case 0x6AB9: L_6ab9: //A9 62 A0
/* 003 [def:0009] [use:0000] */          A=0x62;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6AB9);
/* 006 [def:0001] [use:0001] */      case 0x6ABB: L_6abb: //A0 03 38
/* 007 [def:0021] [use:0000] */          Y=0x03;
/* 008 [def:1801] [use:0020] */          ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6ABB);
/* 010 [def:0001] [use:0001] */      case 0x6ABD: L_6abd: //38 20 95
/* 011 [def:2001] [use:0000] */          C = 1;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6ABD);
/* 013 [def:0001] [use:0001] */      case 0x6ABE: L_6abe: //20 95 7C
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0xC0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6ABE);
/* 017 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6AC1: L_6ac1: //A4 6F A9
/* 001 [def:0021] [use:0001] */          Y=ram[0x006F];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6AC1);
/* 004 [def:0001] [use:0001] */      case 0x6AC3: L_6ac3: //A9 00 20
/* 005 [def:0009] [use:0000] */          A=0x00;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6AC3);
/* 008 [def:0001] [use:0001] */      case 0x6AC5: L_6ac5: //20 74 6B
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0xC7;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6AC5);
/* 012 [def:0001] [use:0001] */          PC = 0x6b74;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6AC8: L_6ac8: //A9 28 20
/* 001 [def:0009] [use:0000] */          A=0x28;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6AC8);
/* 004 [def:0001] [use:0001] */      case 0x6ACA: L_6aca: //20 6F 7C
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xCC;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6ACA);
/* 008 [def:0001] [use:0001] */          PC = 0x7c6f;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6ACD: L_6acd: //A5 1E D0
/* 001 [def:0009] [use:0001] */          A=ram[0x001E];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6ACD);
/* 004 [def:0001] [use:0001] */      case 0x6ACF: L_6acf: //D0 0A AD
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6ACF);
/* 008 [def:0001] [use:0001] */              PC = 0x6adb;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6ACF);
/* 002 [def:0001] [use:0001] */      case 0x6AD1: L_6ad1: //AD 19 02
/* 003 [def:0009] [use:0001] */          A=ram[0x0219];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6AD1);
/* 006 [def:0001] [use:0001] */      case 0x6AD4: L_6ad4: //30 05 F0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6AD4);
/* 010 [def:0001] [use:0001] */              PC = 0x6adb;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6AD4);
/* 002 [def:0001] [use:0001] */      case 0x6AD6: L_6ad6: //F0 03 20
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6AD6);
/* 006 [def:0001] [use:0001] */              PC = 0x6adb;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6AD6);
/* 002 [def:0001] [use:0001] */      case 0x6AD8: L_6ad8: //20 89 6B
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xDA;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6AD8);
/* 006 [def:0001] [use:0001] */          PC = 0x6b89;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6ADB: L_6adb: //A9 00 85
/* 001 [def:0009] [use:0000] */          A=0x00;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6ADB);
/* 004 [def:0001] [use:0001] */      case 0x6ADD: L_6add: //85 01 05
/* 005 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6ADD);
/* 007 [def:0001] [use:0001] */      case 0x6ADF: L_6adf: //05 24 05
/* 008 [def:0009] [use:0009] */          A|=ram[0x0024];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6ADF);
/* 011 [def:0001] [use:0001] */      case 0x6AE1: L_6ae1: //05 25 F0
/* 012 [def:0009] [use:0009] */          A|=ram[0x0025];
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6AE1);
/* 015 [def:0001] [use:0001] */      case 0x6AE3: L_6ae3: //F0 1E A9
/* 016 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x6AE3);
/* 019 [def:0001] [use:0001] */              PC = 0x6b03;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6AE3);
/* 002 [def:0001] [use:0001] */      case 0x6AE5: L_6ae5: //A9 74 A2
/* 003 [def:0009] [use:0000] */          A=0x74;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6AE5);
/* 006 [def:0001] [use:0001] */      case 0x6AE7: L_6ae7: //A2 DB 20
/* 007 [def:0001] [use:0001] */          X=0xDB;
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6AE7);
/* 010 [def:0001] [use:0001] */      case 0x6AE9: L_6ae9: //20 1F 7A
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0xEB;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6AE9);
/* 014 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 25; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6AEC: L_6aec: //A9 50 20
/* 001 [def:0009] [use:0000] */          A=0x50;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6AEC);
/* 004 [def:0001] [use:0001] */      case 0x6AEE: L_6aee: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xF0;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6AEE);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6AF1: L_6af1: //A9 23 A0
/* 001 [def:0009] [use:0000] */          A=0x23;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6AF1);
/* 004 [def:0001] [use:0001] */      case 0x6AF3: L_6af3: //A0 03 38
/* 005 [def:0021] [use:0000] */          Y=0x03;
/* 006 [def:1801] [use:0020] */          ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6AF3);
/* 008 [def:0001] [use:0001] */      case 0x6AF5: L_6af5: //38 20 95
/* 009 [def:2001] [use:0000] */          C = 1;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6AF5);
/* 011 [def:0001] [use:0001] */      case 0x6AF6: L_6af6: //20 95 7C
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 013 [def:0001] [use:0001] */          stack[S--] = 0xF8;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6AF6);
/* 015 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6AF9: L_6af9: //A0 00 84
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6AF9);
/* 004 [def:0001] [use:0001] */      case 0x6AFB: L_6afb: //84 13 20
/* 005 [def:0001] [use:0020] */          ram[0x0013] = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6AFB);
/* 007 [def:0001] [use:0001] */      case 0x6AFD: L_6afd: //20 F8 79
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x6A;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0xFF;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6AFD);
/* 011 [def:0001] [use:0001] */          PC = 0x79f8;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B00: L_6b00: //20 42 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x02;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B00);
/* 004 [def:0001] [use:0001] */          PC = 0x6d42;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B03: L_6b03: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B03);
/* 004 [def:0001] [use:0001] */      case 0x6B05: L_6b05: //F0 16 A5
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6B05);
/* 008 [def:0001] [use:0001] */              PC = 0x6b1d;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B05);
/* 002 [def:0001] [use:0001] */      case 0x6B07: L_6b07: //A5 F9 30
/* 003 [def:0009] [use:0001] */          A=ram[0x00F9];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B07);
/* 006 [def:0001] [use:0001] */      case 0x6B09: L_6b09: //30 12 A0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6B09);
/* 010 [def:0001] [use:0001] */              PC = 0x6b1d;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B09);
/* 002 [def:0001] [use:0001] */      case 0x6B0B: L_6b0b: //A0 0D A9
/* 003 [def:0021] [use:0000] */          Y=0x0D;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B0B);
/* 006 [def:0001] [use:0001] */      case 0x6B0D: L_6b0d: //A9 00 20
/* 007 [def:0009] [use:0000] */          A=0x00;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6B0D);
/* 010 [def:0001] [use:0001] */      case 0x6B0F: L_6b0f: //20 62 71
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x11;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6B0F);
/* 014 [def:0001] [use:0001] */          PC = 0x7162;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B12: L_6b12: //A9 68 18
/* 001 [def:0009] [use:0000] */          A=0x68;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B12);
/* 004 [def:0001] [use:0001] */      case 0x6B14: L_6b14: //18 65 20
/* 005 [def:2001] [use:0000] */          C = 0;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6B14);
/* 007 [def:0001] [use:0001] */      case 0x6B15: L_6b15: //65 20 A0
/* 008 [def:b801] [use:6001] */          ADC(ram[0x0020]);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6B15);
/* 010 [def:0001] [use:0001] */      case 0x6B17: L_6b17: //A0 03 38
/* 011 [def:0021] [use:0000] */          Y=0x03;
/* 012 [def:1801] [use:0020] */          ZN = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6B17);
/* 014 [def:0001] [use:0001] */      case 0x6B19: L_6b19: //38 20 95
/* 015 [def:2001] [use:0000] */          C = 1;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6B19);
/* 017 [def:0001] [use:0001] */      case 0x6B1A: L_6b1a: //20 95 7C
/* 018 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x1C;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6B1A);
/* 021 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B1D: L_6b1d: //A2 10 A5
/* 001 [def:0001] [use:0001] */          X=0x10;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B1D);
/* 004 [def:0001] [use:0001] */      case 0x6B1F: L_6b1f: //A5 22 C9
/* 005 [def:0009] [use:0001] */          A=ram[0x0022];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6B1F);
/* 008 [def:0001] [use:0001] */      case 0x6B21: L_6b21: //C9 01 F0
/* 009 [def:0101] [use:0000] */          ZN=0x01;
/* 010 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 011 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6B21);
/* 013 [def:0001] [use:0001] */      case 0x6B23: L_6b23: //F0 63 90
/* 014 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6B23);
/* 017 [def:0001] [use:0001] */              PC = 0x6b88;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B23);
/* 002 [def:0001] [use:0001] */      case 0x6B25: L_6b25: //90 05 A5
/* 003 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6B25);
/* 006 [def:0001] [use:0001] */              PC = 0x6b2c;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B25);
/* 002 [def:0001] [use:0001] */      case 0x6B2C: L_6b2c: //86 01 A9
/* 003 [def:0001] [use:0001] */          ram[0x0001] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6B2C);
/* 005 [def:0001] [use:0001] */      case 0x6B2E: L_6b2e: //A9 C0 A2
/* 006 [def:0009] [use:0000] */          A=0xC0;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6B2E);
/* 009 [def:0001] [use:0001] */      case 0x6B30: L_6b30: //A2 DB 20
/* 010 [def:0001] [use:0001] */          X=0xDB;
/* 011 [def:1801] [use:0010] */          ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6B30);
/* 013 [def:0001] [use:0001] */      case 0x6B32: L_6b32: //20 1F 7A
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x34;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6B32);
/* 017 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B35: L_6b35: //A9 50 20
/* 001 [def:0009] [use:0000] */          A=0x50;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B35);
/* 004 [def:0001] [use:0001] */      case 0x6B37: L_6b37: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x39;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6B37);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B3A: L_6b3a: //A5 22 F0
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B3A);
/* 004 [def:0001] [use:0001] */      case 0x6B3C: L_6b3c: //F0 14 A5
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6B3C);
/* 008 [def:0001] [use:0001] */              PC = 0x6b52;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B3C);
/* 002 [def:0001] [use:0001] */      case 0x6B52: L_6b52: //A9 65 A0
/* 003 [def:0009] [use:0000] */          A=0x65;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B52);
/* 006 [def:0001] [use:0001] */      case 0x6B54: L_6b54: //A0 03 38
/* 007 [def:0021] [use:0000] */          Y=0x03;
/* 008 [def:1801] [use:0020] */          ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6B54);
/* 010 [def:0001] [use:0001] */      case 0x6B56: L_6b56: //38 20 95
/* 011 [def:2001] [use:0000] */          C = 1;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6B56);
/* 013 [def:0001] [use:0001] */      case 0x6B57: L_6b57: //20 95 7C
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x59;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6B57);
/* 017 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B5A: L_6b5a: //A4 70 A9
/* 001 [def:0021] [use:0001] */          Y=ram[0x0070];
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B5A);
/* 004 [def:0001] [use:0001] */      case 0x6B5C: L_6b5c: //A9 01 20
/* 005 [def:0009] [use:0000] */          A=0x01;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6B5C);
/* 008 [def:0001] [use:0001] */      case 0x6B5E: L_6b5e: //20 74 6B
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x60;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6B5E);
/* 012 [def:0001] [use:0001] */          PC = 0x6b74;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B61: L_6b61: //A9 CF 20
/* 001 [def:0009] [use:0000] */          A=0xCF;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B61);
/* 004 [def:0001] [use:0001] */      case 0x6B63: L_6b63: //20 6F 7C
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x65;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6B63);
/* 008 [def:0001] [use:0001] */          PC = 0x7c6f;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B66: L_6b66: //A5 1E F0
/* 001 [def:0009] [use:0001] */          A=ram[0x001E];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B66);
/* 004 [def:0001] [use:0001] */      case 0x6B68: L_6b68: //F0 1E AD
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6B68);
/* 008 [def:0001] [use:0001] */              PC = 0x6b88;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B68);
/* 002 [def:0001] [use:0001] */      case 0x6B74: L_6b74: //45 1E F0
/* 003 [def:0001] [use:0001] */          A^=ram[0x001E];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B74);
/* 006 [def:0001] [use:0001] */      case 0x6B76: L_6b76: //F0 09 AE
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6B76);
/* 010 [def:0001] [use:0001] */              PC = 0x6b81;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B76);
/* 002 [def:0001] [use:0001] */      case 0x6B78: L_6b78: //AE 19 03
/* 003 [def:0001] [use:0001] */          X=ram[0x0319];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B78);
/* 006 [def:0001] [use:0001] */      case 0x6B7B: L_6b7b: //30 02 D0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6B7B);
/* 010 [def:0001] [use:0001] */              PC = 0x6b7f;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B7B);
/* 002 [def:0001] [use:0001] */      case 0x6B7D: L_6b7d: //D0 01 C8
/* 003 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6B7D);
/* 006 [def:0001] [use:0001] */              PC = 0x6b80;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B7D);
/* 002 [def:0001] [use:0001] */      case 0x6B7F: L_6b7f: //C8 60 AE
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6B7F);
/* 006 [def:0001] [use:0001] */      case 0x6B80: L_6b80: //60 AE 19
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6B80);
/* 008 [def:0001] [use:0001] */          PC=stack[++S];
/* 009 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 010 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 26; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B81: L_6b81: //AE 19 02
/* 001 [def:0001] [use:0001] */          X=ram[0x0219];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B81);
/* 004 [def:0001] [use:0001] */      case 0x6B84: L_6b84: //F0 F9 30
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6B84);
/* 008 [def:0001] [use:0001] */              PC = 0x6b7f;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B84);
/* 002 [def:0001] [use:0001] */      case 0x6B86: L_6b86: //30 F7 60
/* 003 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6B86);
/* 006 [def:0001] [use:0001] */              PC = 0x6b7f;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B86);
/* 002 [def:0001] [use:0001] */      case 0x6B88: L_6b88: //60 A5 8B
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B88);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B89: L_6b89: //A5 8B C9
/* 001 [def:0009] [use:0001] */          A=ram[0x008B];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B89);
/* 004 [def:0001] [use:0001] */      case 0x6B8B: L_6b8b: //C9 C0 90
/* 005 [def:0101] [use:0000] */          ZN=0xC0;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6B8B);
/* 009 [def:0001] [use:0001] */      case 0x6B8D: L_6b8d: //90 01 60
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6B8D);
/* 013 [def:0001] [use:0001] */              PC = 0x6b90;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6B8D);
/* 002 [def:0001] [use:0001] */      case 0x6B8F: L_6b8f: //60 48 49
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6B8F);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6B90: L_6b90: //48 49 FF
/* 001 [def:0001] [use:0001] */          stack[S--] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6B90);
/* 003 [def:0001] [use:0001] */      case 0x6B91: L_6b91: //49 FF 69
/* 004 [def:0009] [use:0008] */          A ^= 0xFF;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6B91);
/* 007 [def:0001] [use:0001] */      case 0x6B93: L_6b93: //69 C1 85
/* 008 [def:b801] [use:6001] */          ADC(0xC1);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6B93);
/* 010 [def:0001] [use:0001] */      case 0x6B95: L_6b95: //85 8B A5
/* 011 [def:0001] [use:0008] */          ram[0x008B] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6B95);
/* 013 [def:0001] [use:0001] */      case 0x6B97: L_6b97: //A5 79 48
/* 014 [def:0008] [use:0001] */  //      A=ram[0x0079];
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6B97);
/* 017 [def:0001] [use:0001] */      case 0x6B99: L_6b99: //48 A9 40
/* 018 [def:0001] [use:0001] */          stack[S--] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6B99);
/* 020 [def:0001] [use:0001] */      case 0x6B9A: L_6b9a: //A9 40 85
/* 021 [def:0009] [use:0000] */          A=0x40;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6B9A);
/* 024 [def:0001] [use:0001] */      case 0x6B9C: L_6b9c: //85 79 20
/* 025 [def:0001] [use:0008] */          ram[0x0079] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6B9C);
/* 027 [def:0001] [use:0001] */      case 0x6B9E: L_6b9e: //20 20 6E
/* 028 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 029 [def:0001] [use:0001] */          stack[S--] = 0xA0;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6B9E);
/* 031 [def:0001] [use:0001] */          PC = 0x6e20;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BA1: L_6ba1: //68 85 79
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BA1);
/* 004 [def:0001] [use:0001] */      case 0x6BA2: L_6ba2: //85 79 68
/* 005 [def:0001] [use:0008] */          ram[0x0079] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6BA2);
/* 007 [def:0001] [use:0001] */      case 0x6BA4: L_6ba4: //68 85 8B
/* 008 [def:0001] [use:0001] */          A=stack[++S];
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6BA4);
/* 011 [def:0001] [use:0001] */      case 0x6BA5: L_6ba5: //85 8B 60
/* 012 [def:0001] [use:0008] */          ram[0x008B] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6BA5);
/* 014 [def:0001] [use:0001] */      case 0x6BA7: L_6ba7: //60 84 01
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6BA7);
/* 016 [def:0001] [use:0001] */          PC=stack[++S];
/* 017 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 018 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BA8: L_6ba8: //84 01 86
/* 001 [def:0001] [use:0020] */          ram[0x0001] = Y;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6BA8);
/* 003 [def:0001] [use:0001] */      case 0x6BAA: L_6baa: //86 0E 46
/* 004 [def:0001] [use:0001] */          ram[0x000E] = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6BAA);
/* 006 [def:0001] [use:0001] */      case 0x6BAC: L_6bac: //46 06 66
/* 007 [def:0101] [use:0001] */          ZN=ram[0x0006];
/* 008 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 009 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 010 [def:0001] [use:0100] */          ram[0x0006] = ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6BAC);
/* 012 [def:0001] [use:0001] */      case 0x6BAE: L_6bae: //66 05 46
/* 013 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 014 [def:0101] [use:0001] */          ZN=ram[0x0005];
/* 015 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 016 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 017 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 018 [def:0001] [use:0100] */          ram[0x0005] = ZN;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6BAE);
/* 020 [def:0001] [use:0001] */      case 0x6BB0: L_6bb0: //46 06 66
/* 021 [def:0101] [use:0001] */          ZN=ram[0x0006];
/* 022 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 023 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 024 [def:0001] [use:0100] */          ram[0x0006] = ZN;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6BB0);
/* 026 [def:0001] [use:0001] */      case 0x6BB2: L_6bb2: //66 05 46
/* 027 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 028 [def:0101] [use:0001] */          ZN=ram[0x0005];
/* 029 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 030 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 031 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 032 [def:0001] [use:0100] */          ram[0x0005] = ZN;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6BB2);
/* 034 [def:0001] [use:0001] */      case 0x6BB4: L_6bb4: //46 06 66
/* 035 [def:0101] [use:0001] */          ZN=ram[0x0006];
/* 036 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 037 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 038 [def:0001] [use:0100] */          ram[0x0006] = ZN;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6BB4);
/* 040 [def:0001] [use:0001] */      case 0x6BB6: L_6bb6: //66 05 46
/* 041 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 042 [def:0101] [use:0001] */          ZN=ram[0x0005];
/* 043 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 044 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 045 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 046 [def:0001] [use:0100] */          ram[0x0005] = ZN;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6BB6);
/* 048 [def:0001] [use:0001] */      case 0x6BB8: L_6bb8: //46 08 66
/* 049 [def:0101] [use:0001] */          ZN=ram[0x0008];
/* 050 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 051 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 052 [def:0001] [use:0100] */          ram[0x0008] = ZN;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6BB8);
/* 054 [def:0001] [use:0001] */      case 0x6BBA: L_6bba: //66 07 46
/* 055 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 056 [def:0101] [use:0001] */          ZN=ram[0x0007];
/* 057 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 058 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 059 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 060 [def:0001] [use:0100] */          ram[0x0007] = ZN;
/* 061 [def:0001] [use:0001] */          //trace_PC(0x6BBA);
/* 062 [def:0001] [use:0001] */      case 0x6BBC: L_6bbc: //46 08 66
/* 063 [def:0101] [use:0001] */          ZN=ram[0x0008];
/* 064 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 065 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 066 [def:0001] [use:0100] */          ram[0x0008] = ZN;
/* 067 [def:0001] [use:0001] */          //trace_PC(0x6BBC);
/* 068 [def:0001] [use:0001] */      case 0x6BBE: L_6bbe: //66 07 E6
/* 069 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 070 [def:0101] [use:0001] */          ZN=ram[0x0007];
/* 071 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 072 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 073 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 074 [def:0001] [use:0100] */          ram[0x0007] = ZN;
/* 075 [def:0001] [use:0001] */          //trace_PC(0x6BBE);
/* 076 [def:0001] [use:0001] */      case 0x6BC0: L_6bc0: //E6 08 46
/* 077 [def:1801] [use:0001] */          ZN=++ram[0x0008];
/* 078 [def:0001] [use:0001] */          //trace_PC(0x6BC0);
/* 079 [def:0001] [use:0001] */      case 0x6BC2: L_6bc2: //46 08 66
/* 080 [def:0101] [use:0001] */          ZN=ram[0x0008];
/* 081 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 082 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 083 [def:0001] [use:0100] */          ram[0x0008] = ZN;
/* 084 [def:0001] [use:0001] */          //trace_PC(0x6BC2);
/* 085 [def:0001] [use:0001] */      case 0x6BC4: L_6bc4: //66 07 20
/* 086 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 087 [def:0101] [use:0001] */          ZN=ram[0x0007];
/* 088 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 089 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 090 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 091 [def:0001] [use:0100] */          ram[0x0007] = ZN;
/* 092 [def:0001] [use:0001] */          //trace_PC(0x6BC4);
/* 093 [def:0001] [use:0001] */      case 0x6BC6: L_6bc6: //20 27 6C
/* 094 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 095 [def:0001] [use:0001] */          stack[S--] = 0xC8;
/* 096 [def:0001] [use:0001] */          //trace_PC(0x6BC6);
/* 097 [def:0001] [use:0001] */          PC = 0x6c27;
/*                           */          clockticks += 75; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BC9: L_6bc9: //A6 0E 20
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BC9);
/* 004 [def:0001] [use:0001] */      case 0x6BCB: L_6bcb: //20 D1 6B
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6B;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xCD;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6BCB);
/* 008 [def:0001] [use:0001] */          PC = 0x6bd1;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BCE: L_6bce: //A6 0E 60
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BCE);
/* 004 [def:0001] [use:0001] */      case 0x6BD0: L_6bd0: //60 BD 00
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6BD0);
/* 006 [def:0001] [use:0001] */          PC=stack[++S];
/* 007 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 008 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BD1: L_6bd1: //BD 00 02
/* 001 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BD1);
/* 004 [def:0001] [use:0001] */      case 0x6BD4: L_6bd4: //10 13 E0
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6BD4);
/* 008 [def:0001] [use:0001] */              PC = 0x6be9;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BD4);
/* 002 [def:0001] [use:0001] */      case 0x6BD6: L_6bd6: //E0 19 F0
/* 003 [def:0101] [use:0000] */          ZN=0x19;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6BD6);
/* 007 [def:0001] [use:0001] */      case 0x6BD8: L_6bd8: //F0 0C 29
/* 008 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6BD8);
/* 011 [def:0001] [use:0001] */              PC = 0x6be6;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BD8);
/* 002 [def:0001] [use:0001] */      case 0x6BDA: L_6bda: //29 0C 4A
/* 003 [def:0009] [use:0008] */          A &= 0x0C;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6BDA);
/* 006 [def:0001] [use:0001] */      case 0x6BDC: L_6bdc: //4A A8 B9
/* 007 [def:2001] [use:0008] */          C = A & 0x01;
/* 008 [def:0009] [use:0008] */          A = A >> 1;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6BDC);
/* 011 [def:0001] [use:0001] */      case 0x6BDD: L_6bdd: //A8 B9 80
/* 012 [def:0021] [use:0008] */          Y=A;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6BDD);
/* 015 [def:0001] [use:0001] */      case 0x6BDE: L_6bde: //B9 80 4D
/* 016 [def:0009] [use:0021] */          A=ram[0x4D80 + Y /* can't wrap */];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6BDE);
/* 019 [def:0001] [use:0001] */      case 0x6BE1: L_6be1: //BE 81 4D
/* 020 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x4D81 + Y)];
/* 021 [def:1801] [use:0010] */          ZN = X;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6BE1);
/* 023 [def:0001] [use:0001] */      case 0x6BE4: L_6be4: //D0 1F 4C
/* 024 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 025 [def:0001] [use:0001] */          {
/* 026 [def:0001] [use:0001] */              //trace_PC(0x6BE4);
/* 027 [def:0001] [use:0001] */              PC = 0x6c05;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BE4);
/* 002 [def:0001] [use:0001] */      case 0x6BE6: L_6be6: //4C 5B 6D
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BE6);
/* 004 [def:0001] [use:0001] */          PC = 0x6d5b;
/*                           */          clockticks += 31; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BE9: L_6be9: //E0 19 F0
/* 001 [def:0101] [use:0000] */          ZN=0x19;
/* 002 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 003 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6BE9);
/* 005 [def:0001] [use:0001] */      case 0x6BEB: L_6beb: //F0 1B E0
/* 006 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6BEB);
/* 009 [def:0001] [use:0001] */              PC = 0x6c08;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BEB);
/* 002 [def:0001] [use:0001] */      case 0x6BED: L_6bed: //E0 1A F0
/* 003 [def:0101] [use:0000] */          ZN=0x1A;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6BED);
/* 007 [def:0001] [use:0001] */      case 0x6BEF: L_6bef: //F0 1D B0
/* 008 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6BEF);
/* 011 [def:0001] [use:0001] */              PC = 0x6c0e;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BEF);
/* 002 [def:0001] [use:0001] */      case 0x6BF1: L_6bf1: //B0 21 0A
/* 003 [def:0001] [use:2001] */          if (C)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6BF1);
/* 006 [def:0001] [use:0001] */              PC = 0x6c14;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BF1);
/* 002 [def:0001] [use:0001] */      case 0x6BF3: L_6bf3: //0A 10 03
/* 003 [def:2001] [use:0008] */          C = A & 0x80;
/* 004 [def:0009] [use:0008] */          A = A << 1;
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6BF3);
/* 007 [def:0001] [use:0001] */      case 0x6BF4: L_6bf4: //10 03 4C
/* 008 [def:0001] [use:1001] */          if (ZN < 0)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6BF4);
/* 011 [def:0001] [use:0001] */              PC = 0x6bf9;
/*                           */              clockticks += 17;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6BF4);
/* 002 [def:0001] [use:0001] */      case 0x6BF6: L_6bf6: //4C 75 4A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6BF6);
/* 004 [def:0001] [use:0001] */          PC = 0x4a75;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6BF9: L_6bf9: //4A 4A 4A
/* 001 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 002 [def:0009] [use:0008] */          A = A >> 1;
/* 003 [def:1800] [use:0008] */  //      ZN = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6BF9);
/* 005 [def:0001] [use:0001] */      case 0x6BFA: L_6bfa: //4A 4A 29
/* 006 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 007 [def:0009] [use:0008] */          A = A >> 1;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6BFA);
/* 010 [def:0001] [use:0001] */      case 0x6BFB: L_6bfb: //4A 29 06
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6BFB);
/* 015 [def:0001] [use:0001] */      case 0x6BFC: L_6bfc: //29 06 A8
/* 016 [def:0009] [use:0008] */          A &= 0x06;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6BFC);
/* 019 [def:0001] [use:0001] */      case 0x6BFE: L_6bfe: //A8 B9 9D
/* 020 [def:0021] [use:0008] */          Y=A;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6BFE);
/* 023 [def:0001] [use:0001] */      case 0x6BFF: L_6bff: //B9 9D 77
/* 024 [def:0009] [use:0021] */          A=ram[0x779D + Y /* can't wrap */];
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6BFF);
/* 027 [def:0001] [use:0001] */      case 0x6C02: L_6c02: //BE 9E 77
/* 028 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x779E + Y)];
/* 029 [def:1801] [use:0010] */          ZN = X;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6C02);
/* 031 [def:0001] [use:0001] */      case 0x6C05: L_6c05: //4C D5 7C
/* 032 [def:0001] [use:0001] */          //trace_PC(0x6C05);
/* 033 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C08: L_6c08: //20 81 66
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x0A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C08);
/* 004 [def:0001] [use:0001] */          PC = 0x6681;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C0B: L_6c0b: //4C 20 6E
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C0B);
/* 002 [def:0001] [use:0001] */          PC = 0x6e20;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C0E: L_6c0e: //A9 34 A2
/* 001 [def:0009] [use:0000] */          A=0x34;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C0E);
/* 004 [def:0001] [use:0001] */      case 0x6C10: L_6c10: //A2 C7 D0
/* 005 [def:0001] [use:0001] */          X=0xC7;
/* 006 [def:1801] [use:0010] */          ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6C10);
/* 008 [def:0001] [use:0001] */      case 0x6C12: L_6c12: //D0 F1 A9
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6C12);
/* 012 [def:0001] [use:0001] */              PC = 0x6c05;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C12);
/* 002 [def:0001] [use:0001] */      case 0x6C14: L_6c14: //A9 70 A2
/* 003 [def:0009] [use:0000] */          A=0x70;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6C14);
/* 006 [def:0001] [use:0001] */      case 0x6C16: L_6c16: //A2 F0 20
/* 007 [def:0001] [use:0001] */          X=0xF0;
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6C16);
/* 010 [def:0001] [use:0001] */      case 0x6C18: L_6c18: //20 EC 7A
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x1A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6C18);
/* 014 [def:0001] [use:0001] */          PC = 0x7aec;
/*                           */          clockticks += 20; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C1B: L_6c1b: //A6 0E A5
/* 001 [def:0001] [use:0001] */          X=ram[0x000E];
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C1B);
/* 004 [def:0001] [use:0001] */      case 0x6C1D: L_6c1d: //A5 76 29
/* 005 [def:0009] [use:0001] */          A=ram[0x0076];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6C1D);
/* 008 [def:0001] [use:0001] */      case 0x6C1F: L_6c1f: //29 03 D0
/* 009 [def:0009] [use:0008] */          A &= 0x03;
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6C1F);
/* 012 [def:0001] [use:0001] */      case 0x6C21: L_6c21: //D0 03 DE
/* 013 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x6C21);
/* 016 [def:0001] [use:0001] */              PC = 0x6c26;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C21);
/* 002 [def:0001] [use:0001] */      case 0x6C23: L_6c23: //DE 00 02
/* 003 [def:0101] [use:0011] */          ZN=ram[(unsigned short)(0x0200 + X)];
/* 004 [def:1901] [use:0100] */          ZN--;
/* 005 [def:0001] [use:0111] */          ram[(unsigned short)(0x0200 + X)] = ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6C23);
/* 007 [def:0001] [use:0001] */      case 0x6C26: L_6c26: //60 A2 05
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6C26);
/* 009 [def:0001] [use:0001] */          PC=stack[++S];
/* 010 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 011 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C27: L_6c27: //A2 05 20
/* 001 [def:0001] [use:0001] */          X=0x05;
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C27);
/* 004 [def:0001] [use:0001] */      case 0x6C29: L_6c29: //20 38 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x2B;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6C29);
/* 008 [def:0001] [use:0001] */          PC = 0x7a38;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C2C: L_6c2c: //A9 70 38
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C2C);
/* 004 [def:0001] [use:0001] */      case 0x6C2E: L_6c2e: //38 E5 01
/* 005 [def:2001] [use:0000] */          C = 1;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6C2E);
/* 007 [def:0001] [use:0001] */      case 0x6C2F: L_6c2f: //E5 01 C9
/* 008 [def:b809] [use:6009] */          SBC(ram[0x0001]);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6C2F);
/* 010 [def:0001] [use:0001] */      case 0x6C31: L_6c31: //C9 A0 90
/* 011 [def:0101] [use:0000] */          ZN=0xA0;
/* 012 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 013 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6C31);
/* 015 [def:0001] [use:0001] */      case 0x6C33: L_6c33: //90 0C 48
/* 016 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x6C33);
/* 019 [def:0001] [use:0001] */              PC = 0x6c41;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C33);
/* 002 [def:0001] [use:0001] */      case 0x6C35: L_6c35: //48 A9 90
/* 003 [def:0001] [use:0001] */          stack[S--] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6C35);
/* 005 [def:0001] [use:0001] */      case 0x6C36: L_6c36: //A9 90 20
/* 006 [def:0009] [use:0000] */          A=0x90;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6C36);
/* 009 [def:0001] [use:0001] */      case 0x6C38: L_6c38: //20 EA 7A
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x3A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6C38);
/* 013 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 25; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C3B: L_6c3b: //68 38 E9
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C3B);
/* 004 [def:0001] [use:0001] */      case 0x6C3C: L_6c3c: //38 E9 10
/* 005 [def:2001] [use:0000] */          C = 1;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6C3C);
/* 007 [def:0001] [use:0001] */      case 0x6C3D: L_6c3d: //E9 10 D0
/* 008 [def:b809] [use:6009] */          SBC(0x10);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6C3D);
/* 010 [def:0001] [use:0001] */      case 0x6C3F: L_6c3f: //D0 F0 4C
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6C3F);
/* 014 [def:0001] [use:0001] */              PC = 0x6c31;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C3F);
/* 002 [def:0001] [use:0001] */      case 0x6C41: L_6c41: //4C EA 7A
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C41);
/* 004 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C44: L_6c44: //6A 66 10
/* 001 [def:10001] [use:2000] */          saveflags = C;
/* 002 [def:2001] [use:0008] */          C = A & 0x01;
/* 003 [def:0009] [use:0008] */          A = A >> 1;
/* 004 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6C44);
/* 007 [def:0001] [use:0001] */      case 0x6C45: L_6c45: //66 10 4A
/* 008 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 009 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 010 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 011 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 012 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 013 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6C45);
/* 015 [def:0001] [use:0001] */      case 0x6C47: L_6c47: //4A 66 10
/* 016 [def:2001] [use:0008] */          C = A & 0x01;
/* 017 [def:0009] [use:0008] */          A = A >> 1;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6C47);
/* 020 [def:0001] [use:0001] */      case 0x6C48: L_6c48: //66 10 4A
/* 021 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 022 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 023 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 024 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 025 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 026 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6C48);
/* 028 [def:0001] [use:0001] */      case 0x6C4A: L_6c4a: //4A 66 10
/* 029 [def:2001] [use:0008] */          C = A & 0x01;
/* 030 [def:0009] [use:0008] */          A = A >> 1;
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x6C4A);
/* 033 [def:0001] [use:0001] */      case 0x6C4B: L_6c4b: //66 10 4A
/* 034 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 035 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 036 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 037 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 038 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 039 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6C4B);
/* 041 [def:0001] [use:0001] */      case 0x6C4D: L_6c4d: //4A 66 10
/* 042 [def:2001] [use:0008] */          C = A & 0x01;
/* 043 [def:0009] [use:0008] */          A = A >> 1;
/* 044 [def:1800] [use:0008] */  //      ZN = A;
/* 045 [def:0001] [use:0001] */          //trace_PC(0x6C4D);
/* 046 [def:0001] [use:0001] */      case 0x6C4E: L_6c4e: //66 10 85
/* 047 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 048 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 049 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 050 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 051 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 052 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x6C4E);
/* 054 [def:0001] [use:0001] */      case 0x6C50: L_6c50: //85 11 F8
/* 055 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 056 [def:0001] [use:0001] */          //trace_PC(0x6C50);
/* 057 [def:0001] [use:0001] */      case 0x6C52: L_6c52: //F8 86 12
/* 058 [def:0001] [use:0001] */          P |= 0x08; // sed
/* 059 [def:0001] [use:0001] */          //trace_PC(0x6C52);
/* 060 [def:0001] [use:0001] */      case 0x6C53: L_6c53: //86 12 A6
/* 061 [def:0001] [use:0001] */          ram[0x0012] = X;
/* 062 [def:0001] [use:0001] */          //trace_PC(0x6C53);
/* 063 [def:0001] [use:0001] */      case 0x6C55: L_6c55: //A6 20 A5
/* 064 [def:0001] [use:0001] */          X=ram[0x0020];
/* 065 [def:1800] [use:0010] */  //      ZN = X;
/* 066 [def:0001] [use:0001] */          //trace_PC(0x6C55);
/* 067 [def:0001] [use:0001] */      case 0x6C57: L_6c57: //A5 10 29
/* 068 [def:0009] [use:0001] */          A=ram[0x0010];
/* 069 [def:1800] [use:0008] */  //      ZN = A;
/* 070 [def:0001] [use:0001] */          //trace_PC(0x6C57);
/* 071 [def:0001] [use:0001] */      case 0x6C59: L_6c59: //29 F0 18
/* 072 [def:0009] [use:0008] */          A &= 0xF0;
/* 073 [def:1800] [use:0008] */  //      ZN = A;
/* 074 [def:0001] [use:0001] */          //trace_PC(0x6C59);
/* 075 [def:0001] [use:0001] */      case 0x6C5B: L_6c5b: //18 75 62
/* 076 [def:2001] [use:0000] */          C = 0;
/* 077 [def:0001] [use:0001] */          //trace_PC(0x6C5B);
/* 078 [def:0001] [use:0001] */      case 0x6C5C: L_6c5c: //75 62 95
/* 079 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x62 + X)]); /* zero page */
/* 080 [def:0001] [use:0001] */          //trace_PC(0x6C5C);
/* 081 [def:0001] [use:0001] */      case 0x6C5E: L_6c5e: //95 62 A5
/* 082 [def:0001] [use:0019] */          ram[(unsigned char)(0x62 + X)] = A;
/* 083 [def:0001] [use:0001] */          //trace_PC(0x6C5E);
/* 084 [def:0001] [use:0001] */      case 0x6C60: L_6c60: //A5 11 75
/* 085 [def:0009] [use:0001] */          A=ram[0x0011];
/* 086 [def:1800] [use:0008] */  //      ZN = A;
/* 087 [def:0001] [use:0001] */          //trace_PC(0x6C60);
/* 088 [def:0001] [use:0001] */      case 0x6C62: L_6c62: //75 63 95
/* 089 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x63 + X)]); /* zero page */
/* 090 [def:0001] [use:0001] */          //trace_PC(0x6C62);
/* 091 [def:0001] [use:0001] */      case 0x6C64: L_6c64: //95 63 A9
/* 092 [def:0001] [use:0019] */          ram[(unsigned char)(0x63 + X)] = A;
/* 093 [def:0001] [use:0001] */          //trace_PC(0x6C64);
/* 094 [def:0001] [use:0001] */      case 0x6C66: L_6c66: //A9 00 75
/* 095 [def:0009] [use:0000] */          A=0x00;
/* 096 [def:1800] [use:0008] */  //      ZN = A;
/* 097 [def:0001] [use:0001] */          //trace_PC(0x6C66);
/* 098 [def:0001] [use:0001] */      case 0x6C68: L_6c68: //75 64 95
/* 099 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x64 + X)]); /* zero page */
/* 100 [def:0001] [use:0001] */          //trace_PC(0x6C68);
/* 101 [def:0001] [use:0001] */      case 0x6C6A: L_6c6a: //95 64 D5
/* 102 [def:0001] [use:0019] */          ram[(unsigned char)(0x64 + X)] = A;
/* 103 [def:0001] [use:0001] */          //trace_PC(0x6C6A);
/* 104 [def:0001] [use:0001] */      case 0x6C6C: L_6c6c: //D5 6A 90
/* 105 [def:0101] [use:0011] */          ZN=(0x006A + X)&0xFF;
/* 106 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 107 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 108 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 109 [def:0001] [use:0001] */          //trace_PC(0x6C6C);
/* 110 [def:0001] [use:0001] */      case 0x6C6E: L_6c6e: //90 21 D0
/* 111 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 112 [def:0001] [use:0001] */          {
/* 113 [def:0001] [use:0001] */              //trace_PC(0x6C6E);
/* 114 [def:0001] [use:0001] */              PC = 0x6c91;
/*                           */              clockticks += 82;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C6E);
/* 002 [def:0001] [use:0001] */      case 0x6C70: L_6c70: //D0 06 B5
/* 003 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6C70);
/* 006 [def:0001] [use:0001] */              PC = 0x6c78;
/*                           */              clockticks += 84;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C70);
/* 002 [def:0001] [use:0001] */      case 0x6C72: L_6c72: //B5 63 D5
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x63 + X)];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6C72);
/* 006 [def:0001] [use:0001] */      case 0x6C74: L_6c74: //D5 69 90
/* 007 [def:0101] [use:0011] */          ZN=(0x0069 + X)&0xFF;
/* 008 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 009 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 010 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6C74);
/* 012 [def:0001] [use:0001] */      case 0x6C76: L_6c76: //90 19 18
/* 013 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x6C76);
/* 016 [def:0001] [use:0001] */              PC = 0x6c91;
/*                           */              clockticks += 94;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C76);
/* 002 [def:0001] [use:0001] */      case 0x6C78: L_6c78: //18 A5 F8
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6C78);
/* 005 [def:0001] [use:0001] */      case 0x6C79: L_6c79: //A5 F8 75
/* 006 [def:0009] [use:0001] */          A=ram[0x00F8];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6C79);
/* 009 [def:0001] [use:0001] */      case 0x6C7B: L_6c7b: //75 69 95
/* 010 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x69 + X)]); /* zero page */
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6C7B);
/* 012 [def:0001] [use:0001] */      case 0x6C7D: L_6c7d: //95 69 A5
/* 013 [def:0001] [use:0019] */          ram[(unsigned char)(0x69 + X)] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6C7D);
/* 015 [def:0001] [use:0001] */      case 0x6C7F: L_6c7f: //A5 F9 75
/* 016 [def:0009] [use:0001] */          A=ram[0x00F9];
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6C7F);
/* 019 [def:0001] [use:0001] */      case 0x6C81: L_6c81: //75 6A 95
/* 020 [def:b809] [use:6019] */          ADC(ram[(unsigned char)(0x6A + X)]); /* zero page */
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6C81);
/* 022 [def:0001] [use:0001] */      case 0x6C83: L_6c83: //95 6A A6
/* 023 [def:0001] [use:0019] */          ram[(unsigned char)(0x6a + X)] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6C83);
/* 025 [def:0001] [use:0001] */      case 0x6C85: L_6c85: //A6 1E B5
/* 026 [def:0001] [use:0001] */          X=ram[0x001E];
/* 027 [def:1800] [use:0010] */  //      ZN = X;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6C85);
/* 029 [def:0001] [use:0001] */      case 0x6C87: L_6c87: //B5 6F C9
/* 030 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x6f + X)];
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x6C87);
/* 033 [def:0001] [use:0001] */      case 0x6C89: L_6c89: //C9 0A B0
/* 034 [def:0101] [use:0000] */          ZN=0x0A;
/* 035 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 036 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x6C89);
/* 038 [def:0001] [use:0001] */      case 0x6C8B: L_6c8b: //B0 04 F6
/* 039 [def:0001] [use:2001] */          if (C)
/* 040 [def:0001] [use:0001] */          {
/* 041 [def:0001] [use:0001] */              //trace_PC(0x6C8B);
/* 042 [def:0001] [use:0001] */              PC = 0x6c91;
/*                           */              clockticks += 130;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C8B);
/* 002 [def:0001] [use:0001] */      case 0x6C8D: L_6c8d: //F6 6F E6
/* 003 [def:0101] [use:0011] */          ZN=(0x006F + X)&0xFF;
/* 004 [def:1901] [use:0101] */          ZN=ram[ZN]+1;
/* 005 [def:0001] [use:0100] */          ram[0x006F] = ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6C8D);
/* 007 [def:0001] [use:0001] */      case 0x6C8F: L_6c8f: //E6 7E D8
/* 008 [def:1801] [use:0001] */          ZN=++ram[0x007E];
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6C8F);
/* 010 [def:0001] [use:0001] */      case 0x6C91: L_6c91: //D8 A6 12
/* 011 [def:0001] [use:0001] */          P &= 0xf7;  //cld
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6C91);
/* 013 [def:0001] [use:0001] */      case 0x6C92: L_6c92: //A6 12 60
/* 014 [def:0001] [use:0001] */          X=ram[0x0012];
/* 015 [def:1801] [use:0010] */          ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6C92);
/* 017 [def:0001] [use:0001] */      case 0x6C94: L_6c94: //60 A5 1E
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6C94);
/* 019 [def:0001] [use:0001] */          PC=stack[++S];
/* 020 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 021 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 151; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C95: L_6c95: //A5 1E 4A
/* 001 [def:0009] [use:0001] */          A=ram[0x001E];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C95);
/* 004 [def:0001] [use:0001] */      case 0x6C97: L_6c97: //4A 6A 8D
/* 005 [def:2001] [use:0008] */          C = A & 0x01;
/* 006 [def:0009] [use:0008] */          A = A >> 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6C97);
/* 009 [def:0001] [use:0001] */      case 0x6C98: L_6c98: //6A 8D 04
/* 010 [def:10001] [use:2000] */          saveflags = C;
/* 011 [def:2001] [use:0008] */          C = A & 0x01;
/* 012 [def:0009] [use:0008] */          A = A >> 1;
/* 013 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6C98);
/* 016 [def:0001] [use:0001] */      case 0x6C99: L_6c99: //8D 04 3C
/* 017 [def:0001] [use:0008] */          ram[0x3C04] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6C99);
/* 019 [def:0001] [use:0001] */      case 0x6C9C: L_6c9c: //60 A6 22
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6C9C);
/* 021 [def:0001] [use:0001] */          PC=stack[++S];
/* 022 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 023 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6C9D: L_6c9d: //A6 22 D0
/* 001 [def:0001] [use:0001] */          X=ram[0x0022];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6C9D);
/* 004 [def:0001] [use:0001] */      case 0x6C9F: L_6c9f: //D0 1C A5
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6C9F);
/* 008 [def:0001] [use:0001] */              PC = 0x6cbd;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6C9F);
/* 002 [def:0001] [use:0001] */      case 0x6CA1: L_6ca1: //A5 77 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0077];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6CA1);
/* 006 [def:0001] [use:0001] */      case 0x6CA3: L_6ca3: //29 04 F0
/* 007 [def:0009] [use:0008] */          A &= 0x04;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6CA3);
/* 010 [def:0001] [use:0001] */      case 0x6CA5: L_6ca5: //F0 18 86
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6CA5);
/* 014 [def:0001] [use:0001] */              PC = 0x6cbf;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6CA5);
/* 002 [def:0001] [use:0001] */      case 0x6CA7: L_6ca7: //86 01 A9
/* 003 [def:0001] [use:0001] */          ram[0x0001] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6CA7);
/* 005 [def:0001] [use:0001] */      case 0x6CA9: L_6ca9: //A9 70 A2
/* 006 [def:0009] [use:0000] */          A=0x70;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6CA9);
/* 009 [def:0001] [use:0001] */      case 0x6CAB: L_6cab: //A2 68 20
/* 010 [def:0001] [use:0001] */          X=0x68;
/* 011 [def:1801] [use:0010] */          ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6CAB);
/* 013 [def:0001] [use:0001] */      case 0x6CAD: L_6cad: //20 1F 7A
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0xAF;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6CAD);
/* 017 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CB0: L_6cb0: //A9 70 20
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CB0);
/* 004 [def:0001] [use:0001] */      case 0x6CB2: L_6cb2: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xB4;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6CB2);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CB5: L_6cb5: //20 48 71
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xB7;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CB5);
/* 004 [def:0001] [use:0001] */          PC = 0x7148;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CB8: L_6cb8: //A0 07 20
/* 001 [def:0021] [use:0000] */          Y=0x07;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CB8);
/* 004 [def:0001] [use:0001] */      case 0x6CBA: L_6cba: //20 59 71
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xBC;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6CBA);
/* 008 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CBD: L_6cbd: //18 60 A5
/* 001 [def:2001] [use:0000] */          C = 0;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6CBD);
/* 003 [def:0001] [use:0001] */      case 0x6CBE: L_6cbe: //60 A5 23
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6CBE);
/* 005 [def:0001] [use:0001] */          PC=stack[++S];
/* 006 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 007 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CBF: L_6cbf: //A5 23 05
/* 001 [def:0009] [use:0001] */          A=ram[0x0023];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CBF);
/* 004 [def:0001] [use:0001] */      case 0x6CC1: L_6cc1: //05 24 05
/* 005 [def:0009] [use:0009] */          A|=ram[0x0024];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6CC1);
/* 008 [def:0001] [use:0001] */      case 0x6CC3: L_6cc3: //05 25 F0
/* 009 [def:0009] [use:0009] */          A|=ram[0x0025];
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6CC3);
/* 012 [def:0001] [use:0001] */      case 0x6CC5: L_6cc5: //F0 E0 A0
/* 013 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x6CC5);
/* 016 [def:0001] [use:0001] */              PC = 0x6ca7;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6CC5);
/* 002 [def:0001] [use:0001] */      case 0x6CC7: L_6cc7: //A0 00 20
/* 003 [def:0021] [use:0000] */          Y=0x00;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6CC7);
/* 006 [def:0001] [use:0001] */      case 0x6CC9: L_6cc9: //20 59 71
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0xCB;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6CC9);
/* 010 [def:0001] [use:0001] */          PC = 0x7159;
/*                           */          clockticks += 20; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CCC: L_6ccc: //A2 00 86
/* 001 [def:0001] [use:0001] */          X=0x00;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CCC);
/* 004 [def:0001] [use:0001] */      case 0x6CCE: L_6cce: //86 10 86
/* 005 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6CCE);
/* 007 [def:0001] [use:0001] */      case 0x6CD0: L_6cd0: //86 13 A9
/* 008 [def:0001] [use:0001] */          ram[0x0013] = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6CD0);
/* 010 [def:0001] [use:0001] */      case 0x6CD2: L_6cd2: //A9 A7 85
/* 011 [def:0009] [use:0000] */          A=0xA7;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6CD2);
/* 014 [def:0001] [use:0001] */      case 0x6CD4: L_6cd4: //85 12 A2
/* 015 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6CD4);
/* 017 [def:0001] [use:0001] */      case 0x6CD6: L_6cd6: //A2 23 A9
/* 018 [def:0001] [use:0001] */          X=0x23;
/* 019 [def:1800] [use:0010] */  //      ZN = X;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6CD6);
/* 021 [def:0001] [use:0001] */      case 0x6CD8: L_6cd8: //A9 10 85
/* 022 [def:0009] [use:0000] */          A=0x10;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6CD8);
/* 025 [def:0001] [use:0001] */      case 0x6CDA: L_6cda: //85 01 86
/* 026 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6CDA);
/* 028 [def:0001] [use:0001] */      case 0x6CDC: L_6cdc: //86 11 B5
/* 029 [def:0001] [use:0001] */          ram[0x0011] = X;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6CDC);
/* 031 [def:0001] [use:0001] */      case 0x6CDE: L_6cde: //B5 00 15
/* 032 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x00 + X)];
/* 033 [def:1800] [use:0008] */  //      ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x6CDE);
/* 035 [def:0001] [use:0001] */      case 0x6CE0: L_6ce0: //15 01 15
/* 036 [def:0001] [use:0001] */          temp=(0x0001 + X)&0xFF;
/* 037 [def:0001] [use:0001] */          ZN=ram[temp];
/* 038 [def:0001] [use:0001] */          A |= ZN;
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6CE0);
/* 041 [def:0001] [use:0001] */      case 0x6CE2: L_6ce2: //15 02 F0
/* 042 [def:0001] [use:0001] */          temp=(0x0002 + X)&0xFF;
/* 043 [def:0001] [use:0001] */          ZN=ram[temp];
/* 044 [def:0001] [use:0001] */          A |= ZN;
/* 045 [def:1801] [use:0008] */          ZN = A;
/* 046 [def:0001] [use:0001] */          //trace_PC(0x6CE2);
/* 047 [def:0001] [use:0001] */      case 0x6CE4: L_6ce4: //F0 5A A9
/* 048 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 049 [def:0001] [use:0001] */          {
/* 050 [def:0001] [use:0001] */              //trace_PC(0x6CE4);
/* 051 [def:0001] [use:0001] */              PC = 0x6d40;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6CE4);
/* 002 [def:0001] [use:0001] */      case 0x6CE6: L_6ce6: //A9 5F A6
/* 003 [def:0009] [use:0000] */          A=0x5F;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6CE6);
/* 006 [def:0001] [use:0001] */      case 0x6CE8: L_6ce8: //A6 12 20
/* 007 [def:0001] [use:0001] */          X=ram[0x0012];
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6CE8);
/* 010 [def:0001] [use:0001] */      case 0x6CEA: L_6cea: //20 1F 7A
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0xEC;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6CEA);
/* 014 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 48; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CED: L_6ced: //A9 40 20
/* 001 [def:0009] [use:0000] */          A=0x40;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CED);
/* 004 [def:0001] [use:0001] */      case 0x6CEF: L_6cef: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6C;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0xF1;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6CEF);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6CF2: L_6cf2: //A5 10 F8
/* 001 [def:0009] [use:0001] */          A=ram[0x0010];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6CF2);
/* 004 [def:0001] [use:0001] */      case 0x6CF4: L_6cf4: //F8 18 69
/* 005 [def:0001] [use:0001] */          P |= 0x08; // sed
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6CF4);
/* 007 [def:0001] [use:0001] */      case 0x6CF5: L_6cf5: //18 69 01
/* 008 [def:2001] [use:0000] */          C = 0;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6CF5);
/* 010 [def:0001] [use:0001] */      case 0x6CF6: L_6cf6: //69 01 D8
/* 011 [def:b801] [use:6001] */          ADC(0x01);
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6CF6);
/* 013 [def:0001] [use:0001] */      case 0x6CF8: L_6cf8: //D8 85 10
/* 014 [def:0001] [use:0001] */          P &= 0xf7;  //cld
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6CF8);
/* 016 [def:0001] [use:0001] */      case 0x6CF9: L_6cf9: //85 10 A9
/* 017 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6CF9);
/* 019 [def:0001] [use:0001] */      case 0x6CFB: L_6cfb: //A9 10 38
/* 020 [def:0009] [use:0000] */          A=0x10;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6CFB);
/* 023 [def:0001] [use:0001] */      case 0x6CFD: L_6cfd: //38 A0 01
/* 024 [def:2001] [use:0000] */          C = 1;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6CFD);
/* 026 [def:0001] [use:0001] */      case 0x6CFE: L_6cfe: //A0 01 20
/* 027 [def:0021] [use:0000] */          Y=0x01;
/* 028 [def:1801] [use:0020] */          ZN = Y;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6CFE);
/* 030 [def:0001] [use:0001] */      case 0x6D00: L_6d00: //20 95 7C
/* 031 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 032 [def:0001] [use:0001] */          stack[S--] = 0x02;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6D00);
/* 034 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D03: L_6d03: //A9 40 AA
/* 001 [def:0009] [use:0000] */          A=0x40;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D03);
/* 004 [def:0001] [use:0001] */      case 0x6D05: L_6d05: //AA 20 EC
/* 005 [def:0011] [use:0008] */          X=A;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D05);
/* 008 [def:0001] [use:0001] */      case 0x6D06: L_6d06: //20 EC 7A
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x08;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6D06);
/* 012 [def:0001] [use:0001] */          PC = 0x7aec;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D09: L_6d09: //A0 00 20
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D09);
/* 004 [def:0001] [use:0001] */      case 0x6D0B: L_6d0b: //20 F8 79
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x0D;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D0B);
/* 008 [def:0001] [use:0001] */          PC = 0x79f8;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D0E: L_6d0e: //A5 11 A0
/* 001 [def:0009] [use:0001] */          A=ram[0x0011];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D0E);
/* 004 [def:0001] [use:0001] */      case 0x6D10: L_6d10: //A0 03 38
/* 005 [def:0021] [use:0000] */          Y=0x03;
/* 006 [def:1801] [use:0020] */          ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D10);
/* 008 [def:0001] [use:0001] */      case 0x6D12: L_6d12: //38 20 95
/* 009 [def:2001] [use:0000] */          C = 1;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6D12);
/* 011 [def:0001] [use:0001] */      case 0x6D13: L_6d13: //20 95 7C
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 013 [def:0001] [use:0001] */          stack[S--] = 0x15;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6D13);
/* 015 [def:0001] [use:0001] */          PC = 0x7c95;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D16: L_6d16: //A0 00 20
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D16);
/* 004 [def:0001] [use:0001] */      case 0x6D18: L_6d18: //20 F8 79
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x1A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D18);
/* 008 [def:0001] [use:0001] */          PC = 0x79f8;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D1B: L_6d1b: //20 42 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x1D;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D1B);
/* 004 [def:0001] [use:0001] */          PC = 0x6d42;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D1E: L_6d1e: //A5 10 C9
/* 001 [def:0009] [use:0001] */          A=ram[0x0010];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D1E);
/* 004 [def:0001] [use:0001] */      case 0x6D20: L_6d20: //C9 04 B0
/* 005 [def:0101] [use:0000] */          ZN=0x04;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6D20);
/* 009 [def:0001] [use:0001] */      case 0x6D22: L_6d22: //B0 0C A5
/* 010 [def:0001] [use:2001] */          if (C)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6D22);
/* 013 [def:0001] [use:0001] */              PC = 0x6d30;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D22);
/* 002 [def:0001] [use:0001] */      case 0x6D24: L_6d24: //A5 12 69
/* 003 [def:0009] [use:0001] */          A=ram[0x0012];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6D24);
/* 006 [def:0001] [use:0001] */      case 0x6D26: L_6d26: //69 02 AA
/* 007 [def:b801] [use:6001] */          ADC(0x02);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6D26);
/* 009 [def:0001] [use:0001] */      case 0x6D28: L_6d28: //AA A9 B2
/* 010 [def:0011] [use:0008] */          X=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6D28);
/* 013 [def:0001] [use:0001] */      case 0x6D29: L_6d29: //A9 B2 A0
/* 014 [def:0009] [use:0000] */          A=0xB2;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6D29);
/* 017 [def:0001] [use:0001] */      case 0x6D2B: L_6d2b: //A0 02 20
/* 018 [def:0021] [use:0000] */          Y=0x02;
/* 019 [def:1801] [use:0020] */          ZN = Y;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6D2B);
/* 021 [def:0001] [use:0001] */      case 0x6D2D: L_6d2d: //20 71 7C
/* 022 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 023 [def:0001] [use:0001] */          stack[S--] = 0x2F;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6D2D);
/* 025 [def:0001] [use:0001] */          PC = 0x7c71;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D30: L_6d30: //A5 12 38
/* 001 [def:0009] [use:0001] */          A=ram[0x0012];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D30);
/* 004 [def:0001] [use:0001] */      case 0x6D32: L_6d32: //38 E9 08
/* 005 [def:2001] [use:0000] */          C = 1;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6D32);
/* 007 [def:0001] [use:0001] */      case 0x6D33: L_6d33: //E9 08 85
/* 008 [def:b809] [use:6009] */          SBC(0x08);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6D33);
/* 010 [def:0001] [use:0001] */      case 0x6D35: L_6d35: //85 12 A6
/* 011 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6D35);
/* 013 [def:0001] [use:0001] */      case 0x6D37: L_6d37: //A6 11 E8
/* 014 [def:0001] [use:0001] */          X=ram[0x0011];
/* 015 [def:1800] [use:0010] */  //      ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6D37);
/* 017 [def:0001] [use:0001] */      case 0x6D39: L_6d39: //E8 E8 E8
/* 018 [def:0011] [use:0010] */          X++;
/* 019 [def:1800] [use:0010] */  //      ZN = X;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6D39);
/* 021 [def:0001] [use:0001] */      case 0x6D3A: L_6d3a: //E8 E8 E0
/* 022 [def:0011] [use:0010] */          X++;
/* 023 [def:1800] [use:0010] */  //      ZN = X;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6D3A);
/* 025 [def:0001] [use:0001] */      case 0x6D3B: L_6d3b: //E8 E0 41
/* 026 [def:0011] [use:0010] */          X++;
/* 027 [def:1800] [use:0010] */  //      ZN = X;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6D3B);
/* 029 [def:0001] [use:0001] */      case 0x6D3C: L_6d3c: //E0 41 90
/* 030 [def:0101] [use:0000] */          ZN=0x41;
/* 031 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 032 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6D3C);
/* 034 [def:0001] [use:0001] */      case 0x6D3E: L_6d3e: //90 98 38
/* 035 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x6D3E);
/* 038 [def:0001] [use:0001] */              PC = 0x6cd8;
/*                           */              clockticks += 25;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D3E);
/* 002 [def:0001] [use:0001] */      case 0x6D40: L_6d40: //38 60 20
/* 003 [def:2001] [use:0000] */          C = 1;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6D40);
/* 005 [def:0001] [use:0001] */      case 0x6D41: L_6d41: //60 20 48
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6D41);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 32; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D42: L_6d42: //20 48 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x44;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D42);
/* 004 [def:0001] [use:0001] */          PC = 0x6d48;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D45: L_6d45: //20 48 6D
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x47;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D45);
/* 004 [def:0001] [use:0001] */          PC = 0x6d48;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D48: L_6d48: //A4 13 20
/* 001 [def:0021] [use:0001] */          Y=ram[0x0013];
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D48);
/* 004 [def:0001] [use:0001] */      case 0x6D4A: L_6d4a: //20 C5 66
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D4A);
/* 008 [def:0001] [use:0001] */          PC = 0x66c5;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D4D: L_6d4d: //E6 13 60
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x0013];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6D4D);
/* 003 [def:0001] [use:0001] */      case 0x6D4F: L_6d4f: //60 A2 18
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6D4F);
/* 005 [def:0001] [use:0001] */          PC=stack[++S];
/* 006 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 007 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D50: L_6d50: //A2 18 BD
/* 001 [def:0001] [use:0001] */          X=0x18;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D50);
/* 004 [def:0001] [use:0001] */      case 0x6D52: L_6d52: //BD 00 02
/* 005 [def:0009] [use:0011] */          A=ram[0x0200 + X /* can't wrap */];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6D52);
/* 008 [def:0001] [use:0001] */      case 0x6D55: L_6d55: //F0 03 CA
/* 009 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6D55);
/* 012 [def:0001] [use:0001] */              PC = 0x6d5a;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D55);
/* 002 [def:0001] [use:0001] */      case 0x6D57: L_6d57: //CA 10 F8
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6D57);
/* 006 [def:0001] [use:0001] */      case 0x6D58: L_6d58: //10 F8 60
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6D58);
/* 010 [def:0001] [use:0001] */              PC = 0x6d52;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D58);
/* 002 [def:0001] [use:0001] */      case 0x6D5A: L_6d5a: //60 AD 19
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D5A);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D5B: L_6d5b: //AD 19 02
/* 001 [def:0009] [use:0001] */          A=ram[0x0219];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6D5B);
/* 004 [def:0001] [use:0001] */      case 0x6D5E: L_6d5e: //C9 A2 B0
/* 005 [def:0101] [use:0000] */          ZN=0xA2;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6D5E);
/* 009 [def:0001] [use:0001] */      case 0x6D60: L_6d60: //B0 3B A2
/* 010 [def:0001] [use:2001] */          if (C)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6D60);
/* 013 [def:0001] [use:0001] */              PC = 0x6d9d;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D60);
/* 002 [def:0001] [use:0001] */      case 0x6D62: L_6d62: //A2 07 AD
/* 003 [def:0001] [use:0001] */          X=0x07;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6D62);
/* 006 [def:0001] [use:0001] */      case 0x6D64: L_6d64: //AD 0A 2C
/* 007 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6D64);
/* 010 [def:0001] [use:0001] */      case 0x6D67: L_6d67: //29 07 45
/* 011 [def:0009] [use:0008] */          A &= 0x07;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6D67);
/* 014 [def:0001] [use:0001] */      case 0x6D69: L_6d69: //45 05 0A
/* 015 [def:0001] [use:0001] */          A^=ram[0x0005];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6D69);
/* 018 [def:0001] [use:0001] */      case 0x6D6B: L_6d6b: //0A 9D 00
/* 019 [def:2001] [use:0008] */          C = A & 0x80;
/* 020 [def:0009] [use:0008] */          A = A << 1;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6D6B);
/* 023 [def:0001] [use:0001] */      case 0x6D6C: L_6d6c: //9D 00 01
/* 024 [def:0001] [use:0019] */          ram[0x0100 + X /* can't wrap */] = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6D6C);
/* 026 [def:0001] [use:0001] */      case 0x6D6F: L_6d6f: //A5 06 2A
/* 027 [def:0009] [use:0001] */          A=ram[0x0006];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6D6F);
/* 030 [def:0001] [use:0001] */      case 0x6D71: L_6d71: //2A 9D 10
/* 031 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 032 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 033 [def:0009] [use:0008] */          A = A << 1;
/* 034 [def:0009] [use:10008] */          A |= saveflags;
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x6D71);
/* 037 [def:0001] [use:0001] */      case 0x6D72: L_6d72: //9D 10 01
/* 038 [def:0001] [use:0019] */          ram[0x0110 + X /* can't wrap */] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6D72);
/* 040 [def:0001] [use:0001] */      case 0x6D75: L_6d75: //AD 0A 2C
/* 041 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x6D75);
/* 044 [def:0001] [use:0001] */      case 0x6D78: L_6d78: //29 07 45
/* 045 [def:0009] [use:0008] */          A &= 0x07;
/* 046 [def:1800] [use:0008] */  //      ZN = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6D78);
/* 048 [def:0001] [use:0001] */      case 0x6D7A: L_6d7a: //45 07 0A
/* 049 [def:0001] [use:0001] */          A^=ram[0x0007];
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x6D7A);
/* 052 [def:0001] [use:0001] */      case 0x6D7C: L_6d7c: //0A 9D 08
/* 053 [def:2001] [use:0008] */          C = A & 0x80;
/* 054 [def:0009] [use:0008] */          A = A << 1;
/* 055 [def:1800] [use:0008] */  //      ZN = A;
/* 056 [def:0001] [use:0001] */          //trace_PC(0x6D7C);
/* 057 [def:0001] [use:0001] */      case 0x6D7D: L_6d7d: //9D 08 01
/* 058 [def:0001] [use:0019] */          ram[0x0108 + X /* can't wrap */] = A;
/* 059 [def:0001] [use:0001] */          //trace_PC(0x6D7D);
/* 060 [def:0001] [use:0001] */      case 0x6D80: L_6d80: //A5 08 2A
/* 061 [def:0009] [use:0001] */          A=ram[0x0008];
/* 062 [def:1800] [use:0008] */  //      ZN = A;
/* 063 [def:0001] [use:0001] */          //trace_PC(0x6D80);
/* 064 [def:0001] [use:0001] */      case 0x6D82: L_6d82: //2A 9D 18
/* 065 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 066 [def:2001] [use:0008] */          C = A & 0x80;
/* 067 [def:0009] [use:0008] */          A = A << 1;
/* 068 [def:0009] [use:10008] */          A |= saveflags;
/* 069 [def:1800] [use:0008] */  //      ZN = A;
/* 070 [def:0001] [use:0001] */          //trace_PC(0x6D82);
/* 071 [def:0001] [use:0001] */      case 0x6D83: L_6d83: //9D 18 01
/* 072 [def:0001] [use:0019] */          ram[0x0118 + X /* can't wrap */] = A;
/* 073 [def:0001] [use:0001] */          //trace_PC(0x6D83);
/* 074 [def:0001] [use:0001] */      case 0x6D86: L_6d86: //AD 0A 2C
/* 075 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 076 [def:1800] [use:0008] */  //      ZN = A;
/* 077 [def:0001] [use:0001] */          //trace_PC(0x6D86);
/* 078 [def:0001] [use:0001] */      case 0x6D89: L_6d89: //29 0F 69
/* 079 [def:0009] [use:0008] */          A &= 0x0F;
/* 080 [def:1800] [use:0008] */  //      ZN = A;
/* 081 [def:0001] [use:0001] */          //trace_PC(0x6D89);
/* 082 [def:0001] [use:0001] */      case 0x6D8B: L_6d8b: //69 F8 9D
/* 083 [def:b801] [use:6001] */          ADC(0xF8);
/* 084 [def:0001] [use:0001] */          //trace_PC(0x6D8B);
/* 085 [def:0001] [use:0001] */      case 0x6D8D: L_6d8d: //9D 20 01
/* 086 [def:0001] [use:0019] */          ram[0x0120 + X /* can't wrap */] = A;
/* 087 [def:0001] [use:0001] */          //trace_PC(0x6D8D);
/* 088 [def:0001] [use:0001] */      case 0x6D90: L_6d90: //20 15 6E
/* 089 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 090 [def:0001] [use:0001] */          stack[S--] = 0x92;
/* 091 [def:0001] [use:0001] */          //trace_PC(0x6D90);
/* 092 [def:0001] [use:0001] */          PC = 0x6e15;
/*                           */          clockticks += 87; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D93: L_6d93: //95 DF 20
/* 001 [def:0001] [use:0019] */          ram[(unsigned char)(0xdf + X)] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6D93);
/* 003 [def:0001] [use:0001] */      case 0x6D95: L_6d95: //20 15 6E
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x97;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6D95);
/* 007 [def:0001] [use:0001] */          PC = 0x6e15;
/*                           */          clockticks += 10; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6D98: L_6d98: //95 E7 CA
/* 001 [def:0001] [use:0019] */          ram[(unsigned char)(0xe7 + X)] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6D98);
/* 003 [def:0001] [use:0001] */      case 0x6D9A: L_6d9a: //CA 10 C7
/* 004 [def:0011] [use:0010] */          X--;
/* 005 [def:1801] [use:0010] */          ZN = X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6D9A);
/* 007 [def:0001] [use:0001] */      case 0x6D9B: L_6d9b: //10 C7 A9
/* 008 [def:0001] [use:1001] */          if (ZN < 0)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6D9B);
/* 011 [def:0001] [use:0001] */              PC = 0x6d64;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6D9B);
/* 002 [def:0001] [use:0001] */      case 0x6D9D: L_6d9d: //A9 07 85
/* 003 [def:0009] [use:0000] */          A=0x07;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6D9D);
/* 006 [def:0001] [use:0001] */      case 0x6D9F: L_6d9f: //85 12 85
/* 007 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6D9F);
/* 009 [def:0001] [use:0001] */      case 0x6DA1: L_6da1: //85 15 A6
/* 010 [def:0001] [use:0008] */          ram[0x0015] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6DA1);
/* 012 [def:0001] [use:0001] */      case 0x6DA3: L_6da3: //A6 15 AD
/* 013 [def:0001] [use:0001] */          X=ram[0x0015];
/* 014 [def:1800] [use:0010] */  //      ZN = X;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6DA3);
/* 016 [def:0001] [use:0001] */      case 0x6DA5: L_6da5: //AD 19 02
/* 017 [def:0009] [use:0001] */          A=ram[0x0219];
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6DA5);
/* 020 [def:0001] [use:0001] */      case 0x6DA8: L_6da8: //20 B6 70
/* 021 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 022 [def:0001] [use:0001] */          stack[S--] = 0xAA;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6DA8);
/* 024 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DAB: L_6dab: //29 F0 69
/* 001 [def:0009] [use:0008] */          A &= 0xF0;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DAB);
/* 004 [def:0001] [use:0001] */      case 0x6DAD: L_6dad: //69 60 85
/* 005 [def:b801] [use:6001] */          ADC(0x60);
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6DAD);
/* 007 [def:0001] [use:0001] */      case 0x6DAF: L_6daf: //85 09 B5
/* 008 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6DAF);
/* 010 [def:0001] [use:0001] */      case 0x6DB1: L_6db1: //B5 EF 7D
/* 011 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xef + X)];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6DB1);
/* 014 [def:0001] [use:0001] */      case 0x6DB3: L_6db3: //7D 20 01
/* 015 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0120 + X)]);
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6DB3);
/* 017 [def:0001] [use:0001] */      case 0x6DB6: L_6db6: //95 EF 4A
/* 018 [def:0001] [use:0019] */          ram[(unsigned char)(0xef + X)] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6DB6);
/* 020 [def:0001] [use:0001] */      case 0x6DB8: L_6db8: //4A 4A 48
/* 021 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 022 [def:0009] [use:0008] */          A = A >> 1;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6DB8);
/* 025 [def:0001] [use:0001] */      case 0x6DB9: L_6db9: //4A 48 4A
/* 026 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 027 [def:0009] [use:0008] */          A = A >> 1;
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6DB9);
/* 030 [def:0001] [use:0001] */      case 0x6DBA: L_6dba: //48 4A 4A
/* 031 [def:0001] [use:0001] */          stack[S--] = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x6DBA);
/* 033 [def:0001] [use:0001] */      case 0x6DBB: L_6dbb: //4A 4A 4A
/* 034 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 035 [def:0009] [use:0008] */          A = A >> 1;
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x6DBB);
/* 038 [def:0001] [use:0001] */      case 0x6DBC: L_6dbc: //4A 4A 29
/* 039 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 040 [def:0009] [use:0008] */          A = A >> 1;
/* 041 [def:1800] [use:0008] */  //      ZN = A;
/* 042 [def:0001] [use:0001] */          //trace_PC(0x6DBC);
/* 043 [def:0001] [use:0001] */      case 0x6DBD: L_6dbd: //4A 29 04
/* 044 [def:2001] [use:0008] */          C = A & 0x01;
/* 045 [def:0009] [use:0008] */          A = A >> 1;
/* 046 [def:1800] [use:0008] */  //      ZN = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6DBD);
/* 048 [def:0001] [use:0001] */      case 0x6DBE: L_6dbe: //29 04 85
/* 049 [def:0009] [use:0008] */          A &= 0x04;
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x6DBE);
/* 052 [def:0001] [use:0001] */      case 0x6DC0: L_6dc0: //85 0A 05
/* 053 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x6DC0);
/* 055 [def:0001] [use:0001] */      case 0x6DC2: L_6dc2: //05 09 85
/* 056 [def:0009] [use:0009] */          A|=ram[0x0009];
/* 057 [def:1801] [use:0008] */          ZN = A;
/* 058 [def:0001] [use:0001] */          //trace_PC(0x6DC2);
/* 059 [def:0001] [use:0001] */      case 0x6DC4: L_6dc4: //85 09 20
/* 060 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 061 [def:0001] [use:0001] */          //trace_PC(0x6DC4);
/* 062 [def:0001] [use:0001] */      case 0x6DC6: L_6dc6: //20 F6 6D
/* 063 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 064 [def:0001] [use:0001] */          stack[S--] = 0xC8;
/* 065 [def:0001] [use:0001] */          //trace_PC(0x6DC6);
/* 066 [def:0001] [use:0001] */          PC = 0x6df6;
/*                           */          clockticks += 49; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DC9: L_6dc9: //85 06 A5
/* 001 [def:0001] [use:0008] */          ram[0x0006] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6DC9);
/* 003 [def:0001] [use:0001] */      case 0x6DCB: L_6dcb: //A5 07 85
/* 004 [def:0009] [use:0001] */          A=ram[0x0007];
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6DCB);
/* 007 [def:0001] [use:0001] */      case 0x6DCD: L_6dcd: //85 05 8A
/* 008 [def:0001] [use:0008] */          ram[0x0005] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6DCD);
/* 010 [def:0001] [use:0001] */      case 0x6DCF: L_6dcf: //8A 18 69
/* 011 [def:0001] [use:0001] */          A=X;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6DCF);
/* 014 [def:0001] [use:0001] */      case 0x6DD0: L_6dd0: //18 69 08
/* 015 [def:2001] [use:0000] */          C = 0;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6DD0);
/* 017 [def:0001] [use:0001] */      case 0x6DD1: L_6dd1: //69 08 AA
/* 018 [def:b801] [use:6001] */          ADC(0x08);
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6DD1);
/* 020 [def:0001] [use:0001] */      case 0x6DD3: L_6dd3: //AA 20 F6
/* 021 [def:0011] [use:0008] */          X=A;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6DD3);
/* 024 [def:0001] [use:0001] */      case 0x6DD4: L_6dd4: //20 F6 6D
/* 025 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 026 [def:0001] [use:0001] */          stack[S--] = 0xD6;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6DD4);
/* 028 [def:0001] [use:0001] */          PC = 0x6df6;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DD7: L_6dd7: //20 27 6C
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xD9;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DD7);
/* 004 [def:0001] [use:0001] */          PC = 0x6c27;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DDA: L_6dda: //68 29 1E
/* 001 [def:0001] [use:0001] */          A=stack[++S];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DDA);
/* 004 [def:0001] [use:0001] */      case 0x6DDB: L_6ddb: //29 1E AA
/* 005 [def:0009] [use:0008] */          A &= 0x1E;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6DDB);
/* 008 [def:0001] [use:0001] */      case 0x6DDD: L_6ddd: //AA BD 6A
/* 009 [def:0011] [use:0008] */          X=A;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6DDD);
/* 012 [def:0001] [use:0001] */      case 0x6DDE: L_6dde: //BD 6A 50
/* 013 [def:0009] [use:0011] */          A=ram[0x506A + X /* can't wrap */];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6DDE);
/* 016 [def:0001] [use:0001] */      case 0x6DE1: L_6de1: //0A 85 10
/* 017 [def:2001] [use:0008] */          C = A & 0x80;
/* 018 [def:0009] [use:0008] */          A = A << 1;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6DE1);
/* 021 [def:0001] [use:0001] */      case 0x6DE2: L_6de2: //85 10 BD
/* 022 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6DE2);
/* 024 [def:0001] [use:0001] */      case 0x6DE4: L_6de4: //BD 6B 50
/* 025 [def:0009] [use:0011] */          A=ram[0x506B + X /* can't wrap */];
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6DE4);
/* 028 [def:0001] [use:0001] */      case 0x6DE7: L_6de7: //2A 49 C0
/* 029 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 030 [def:2001] [use:0008] */          C = A & 0x80;
/* 031 [def:0009] [use:0008] */          A = A << 1;
/* 032 [def:0009] [use:10008] */          A |= saveflags;
/* 033 [def:1800] [use:0008] */  //      ZN = A;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x6DE7);
/* 035 [def:0001] [use:0001] */      case 0x6DE8: L_6de8: //49 C0 85
/* 036 [def:0009] [use:0008] */          A ^= 0xC0;
/* 037 [def:1800] [use:0008] */  //      ZN = A;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x6DE8);
/* 039 [def:0001] [use:0001] */      case 0x6DEA: L_6dea: //85 11 A2
/* 040 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 041 [def:0001] [use:0001] */          //trace_PC(0x6DEA);
/* 042 [def:0001] [use:0001] */      case 0x6DEC: L_6dec: //A2 00 20
/* 043 [def:0001] [use:0001] */          X=0x00;
/* 044 [def:1801] [use:0010] */          ZN = X;
/* 045 [def:0001] [use:0001] */          //trace_PC(0x6DEC);
/* 046 [def:0001] [use:0001] */      case 0x6DEE: L_6dee: //20 21 62
/* 047 [def:0001] [use:0001] */          stack[S--] = 0x6D;
/* 048 [def:0001] [use:0001] */          stack[S--] = 0xF0;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x6DEE);
/* 050 [def:0001] [use:0001] */          PC = 0x6221;
/*                           */          clockticks += 37; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DF1: L_6df1: //C6 15 10
/* 001 [def:0001] [use:0001] */          ZN=ram[0x0015]-1;
/* 002 [def:0001] [use:0001] */          ram[0x0015] = ZN;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DF1);
/* 004 [def:0001] [use:0001] */      case 0x6DF3: L_6df3: //10 AE 60
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6DF3);
/* 008 [def:0001] [use:0001] */              PC = 0x6da3;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6DF3);
/* 002 [def:0001] [use:0001] */      case 0x6DF5: L_6df5: //60 A0 00
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DF5);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6DF6: L_6df6: //A0 00 B5
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6DF6);
/* 004 [def:0001] [use:0001] */      case 0x6DF8: L_6df8: //B5 DF 10
/* 005 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xdf + X)];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6DF8);
/* 008 [def:0001] [use:0001] */      case 0x6DFA: L_6dfa: //10 01 88
/* 009 [def:0001] [use:1001] */          if (ZN < 0)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x6DFA);
/* 012 [def:0001] [use:0001] */              PC = 0x6dfd;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6DFA);
/* 002 [def:0001] [use:0001] */      case 0x6DFC: L_6dfc: //88 18 7D
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6DFC);
/* 006 [def:0001] [use:0001] */      case 0x6DFD: L_6dfd: //18 7D 00
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6DFD);
/* 009 [def:0001] [use:0001] */      case 0x6DFE: L_6dfe: //7D 00 01
/* 010 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0100 + X)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6DFE);
/* 012 [def:0001] [use:0001] */      case 0x6E01: L_6e01: //9D 00 01
/* 013 [def:0001] [use:0019] */          ram[0x0100 + X /* can't wrap */] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6E01);
/* 015 [def:0001] [use:0001] */      case 0x6E04: L_6e04: //85 07 98
/* 016 [def:0001] [use:0008] */          ram[0x0007] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6E04);
/* 018 [def:0001] [use:0001] */      case 0x6E06: L_6e06: //98 7D 10
/* 019 [def:0001] [use:0001] */          A=Y;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6E06);
/* 022 [def:0001] [use:0001] */      case 0x6E07: L_6e07: //7D 10 01
/* 023 [def:b809] [use:6019] */          ADC(ram[(unsigned short)(0x0110 + X)]);
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6E07);
/* 025 [def:0001] [use:0001] */      case 0x6E0A: L_6e0a: //29 07 9D
/* 026 [def:0009] [use:0008] */          A &= 0x07;
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6E0A);
/* 029 [def:0001] [use:0001] */      case 0x6E0C: L_6e0c: //9D 10 01
/* 030 [def:0001] [use:0019] */          ram[0x0110 + X /* can't wrap */] = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x6E0C);
/* 032 [def:0001] [use:0001] */      case 0x6E0F: L_6e0f: //4A 85 08
/* 033 [def:2001] [use:0008] */          C = A & 0x01;
/* 034 [def:0009] [use:0008] */          A = A >> 1;
/* 035 [def:1801] [use:0008] */          ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x6E0F);
/* 037 [def:0001] [use:0001] */      case 0x6E10: L_6e10: //85 08 66
/* 038 [def:0001] [use:0008] */          ram[0x0008] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x6E10);
/* 040 [def:0001] [use:0001] */      case 0x6E12: L_6e12: //66 07 60
/* 041 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 042 [def:0101] [use:0001] */          ZN=ram[0x0007];
/* 043 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 044 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 045 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 046 [def:0001] [use:0100] */          ram[0x0007] = ZN;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6E12);
/* 048 [def:0001] [use:0001] */      case 0x6E14: L_6e14: //60 AD 0A
/* 049 [def:0001] [use:0001] */          //trace_PC(0x6E14);
/* 050 [def:0001] [use:0001] */          PC=stack[++S];
/* 051 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 052 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 53; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E15: L_6e15: //AD 0A 2C
/* 001 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E15);
/* 004 [def:0001] [use:0001] */      case 0x6E18: L_6e18: //29 07 18
/* 005 [def:0009] [use:0008] */          A &= 0x07;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6E18);
/* 008 [def:0001] [use:0001] */      case 0x6E1A: L_6e1a: //18 69 FC
/* 009 [def:2001] [use:0000] */          C = 0;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6E1A);
/* 011 [def:0001] [use:0001] */      case 0x6E1B: L_6e1b: //69 FC 69
/* 012 [def:b801] [use:6001] */          ADC(0xFC);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6E1B);
/* 014 [def:0001] [use:0001] */      case 0x6E1D: L_6e1d: //69 00 60
/* 015 [def:b801] [use:6001] */          ADC(0x00);
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6E1D);
/* 017 [def:0001] [use:0001] */      case 0x6E1F: L_6e1f: //60 A5 8B
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6E1F);
/* 019 [def:0001] [use:0001] */          PC=stack[++S];
/* 020 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 021 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E20: L_6e20: //A5 8B C9
/* 001 [def:0009] [use:0001] */          A=ram[0x008B];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E20);
/* 004 [def:0001] [use:0001] */      case 0x6E22: L_6e22: //C9 C0 B0
/* 005 [def:0101] [use:0000] */          ZN=0xC0;
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6E22);
/* 009 [def:0001] [use:0001] */      case 0x6E24: L_6e24: //B0 4A 69
/* 010 [def:0001] [use:2001] */          if (C)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6E24);
/* 013 [def:0001] [use:0001] */              PC = 0x6e70;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E24);
/* 002 [def:0001] [use:0001] */      case 0x6E26: L_6e26: //69 06 85
/* 003 [def:b801] [use:6001] */          ADC(0x06);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6E26);
/* 005 [def:0001] [use:0001] */      case 0x6E28: L_6e28: //85 8B AD
/* 006 [def:0001] [use:0008] */          ram[0x008B] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6E28);
/* 008 [def:0001] [use:0001] */      case 0x6E2A: L_6e2a: //AD 0A 2C
/* 009 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6E2A);
/* 012 [def:0001] [use:0001] */      case 0x6E2D: L_6e2d: //29 04 85
/* 013 [def:0009] [use:0008] */          A &= 0x04;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6E2D);
/* 016 [def:0001] [use:0001] */      case 0x6E2F: L_6e2f: //85 09 AD
/* 017 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6E2F);
/* 019 [def:0001] [use:0001] */      case 0x6E31: L_6e31: //AD 0A 2C
/* 020 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6E31);
/* 023 [def:0001] [use:0001] */      case 0x6E34: L_6e34: //29 04 85
/* 024 [def:0009] [use:0008] */          A &= 0x04;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6E34);
/* 027 [def:0001] [use:0001] */      case 0x6E36: L_6e36: //85 0A AD
/* 028 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6E36);
/* 030 [def:0001] [use:0001] */      case 0x6E38: L_6e38: //AD 0A 2C
/* 031 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6E38);
/* 034 [def:0001] [use:0001] */      case 0x6E3B: L_6e3b: //29 80 85
/* 035 [def:0009] [use:0008] */          A &= 0x80;
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x6E3B);
/* 038 [def:0001] [use:0001] */      case 0x6E3D: L_6e3d: //85 12 A9
/* 039 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6E3D);
/* 041 [def:0001] [use:0001] */      case 0x6E3F: L_6e3f: //A9 09 85
/* 042 [def:0009] [use:0000] */          A=0x09;
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x6E3F);
/* 045 [def:0001] [use:0001] */      case 0x6E41: L_6e41: //85 15 A9
/* 046 [def:0001] [use:0008] */          ram[0x0015] = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6E41);
/* 048 [def:0001] [use:0001] */      case 0x6E43: L_6e43: //A9 4D A2
/* 049 [def:0009] [use:0000] */          A=0x4D;
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x6E43);
/* 052 [def:0001] [use:0001] */      case 0x6E45: L_6e45: //A2 87 85
/* 053 [def:0001] [use:0001] */          X=0x87;
/* 054 [def:1800] [use:0010] */  //      ZN = X;
/* 055 [def:0001] [use:0001] */          //trace_PC(0x6E45);
/* 056 [def:0001] [use:0001] */      case 0x6E47: L_6e47: //85 11 86
/* 057 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 058 [def:0001] [use:0001] */          //trace_PC(0x6E47);
/* 059 [def:0001] [use:0001] */      case 0x6E49: L_6e49: //86 10 A0
/* 060 [def:0001] [use:0001] */          ram[0x0010] = X;
/* 061 [def:0001] [use:0001] */          //trace_PC(0x6E49);
/* 062 [def:0001] [use:0001] */      case 0x6E4B: L_6e4b: //A0 00 A2
/* 063 [def:0021] [use:0000] */          Y=0x00;
/* 064 [def:1800] [use:0020] */  //      ZN = Y;
/* 065 [def:0001] [use:0001] */          //trace_PC(0x6E4B);
/* 066 [def:0001] [use:0001] */      case 0x6E4D: L_6e4d: //A2 00 20
/* 067 [def:0001] [use:0001] */          X=0x00;
/* 068 [def:1801] [use:0010] */          ZN = X;
/* 069 [def:0001] [use:0001] */          //trace_PC(0x6E4D);
/* 070 [def:0001] [use:0001] */      case 0x6E4F: L_6e4f: //20 96 6E
/* 071 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 072 [def:0001] [use:0001] */          stack[S--] = 0x51;
/* 073 [def:0001] [use:0001] */          //trace_PC(0x6E4F);
/* 074 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 67; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E52: L_6e52: //AD 0A 2C
/* 001 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E52);
/* 004 [def:0001] [use:0001] */      case 0x6E55: L_6e55: //4A A9 00
/* 005 [def:2001] [use:0008] */          C = A & 0x01;
/* 006 [def:0008] [use:0008] */  //      A = A >> 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6E55);
/* 009 [def:0001] [use:0001] */      case 0x6E56: L_6e56: //A9 00 90
/* 010 [def:0009] [use:0000] */          A=0x00;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6E56);
/* 013 [def:0001] [use:0001] */      case 0x6E58: L_6e58: //90 02 A9
/* 014 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6E58);
/* 017 [def:0001] [use:0001] */              PC = 0x6e5c;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E58);
/* 002 [def:0001] [use:0001] */      case 0x6E5A: L_6e5a: //A9 70 05
/* 003 [def:0009] [use:0000] */          A=0x70;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6E5A);
/* 006 [def:0001] [use:0001] */      case 0x6E5C: L_6e5c: //05 09 85
/* 007 [def:0009] [use:0009] */          A|=ram[0x0009];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6E5C);
/* 010 [def:0001] [use:0001] */      case 0x6E5E: L_6e5e: //85 09 20
/* 011 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6E5E);
/* 013 [def:0001] [use:0001] */      case 0x6E60: L_6e60: //20 96 6E
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6E60);
/* 017 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 25; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E63: L_6e63: //A5 09 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0009];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E63);
/* 004 [def:0001] [use:0001] */      case 0x6E65: L_6e65: //29 04 85
/* 005 [def:0009] [use:0008] */          A &= 0x04;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6E65);
/* 008 [def:0001] [use:0001] */      case 0x6E67: L_6e67: //85 09 C6
/* 009 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6E67);
/* 011 [def:0001] [use:0001] */      case 0x6E69: L_6e69: //C6 15 10
/* 012 [def:0001] [use:0001] */          ZN=ram[0x0015]-1;
/* 013 [def:0001] [use:0001] */          ram[0x0015] = ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6E69);
/* 015 [def:0001] [use:0001] */      case 0x6E6B: L_6e6b: //10 E2 20
/* 016 [def:0001] [use:1001] */          if (ZN < 0)
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x6E6B);
/* 019 [def:0001] [use:0001] */              PC = 0x6e4f;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E6B);
/* 002 [def:0001] [use:0001] */      case 0x6E6D: L_6e6d: //20 96 6E
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6E6D);
/* 006 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E70: L_6e70: //20 A5 6E
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x72;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E70);
/* 004 [def:0001] [use:0001] */          PC = 0x6ea5;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E73: L_6e73: //20 21 62
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0x75;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E73);
/* 004 [def:0001] [use:0001] */          PC = 0x6221;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E76: L_6e76: //A5 8B 29
/* 001 [def:0009] [use:0001] */          A=ram[0x008B];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6E76);
/* 004 [def:0001] [use:0001] */      case 0x6E78: L_6e78: //29 F0 C9
/* 005 [def:0009] [use:0008] */          A &= 0xF0;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6E78);
/* 008 [def:0001] [use:0001] */      case 0x6E7A: L_6e7a: //C9 60 B0
/* 009 [def:0101] [use:0000] */          ZN=0x60;
/* 010 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 011 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6E7A);
/* 013 [def:0001] [use:0001] */      case 0x6E7C: L_6e7c: //B0 02 A9
/* 014 [def:0001] [use:2001] */          if (C)
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6E7C);
/* 017 [def:0001] [use:0001] */              PC = 0x6e80;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E7C);
/* 002 [def:0001] [use:0001] */      case 0x6E7E: L_6e7e: //A9 60 05
/* 003 [def:0009] [use:0000] */          A=0x60;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6E7E);
/* 006 [def:0001] [use:0001] */      case 0x6E80: L_6e80: //05 09 85
/* 007 [def:0009] [use:0009] */          A|=ram[0x0009];
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6E80);
/* 010 [def:0001] [use:0001] */      case 0x6E82: L_6e82: //85 09 A2
/* 011 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6E82);
/* 013 [def:0001] [use:0001] */      case 0x6E84: L_6e84: //A2 07 20
/* 014 [def:0001] [use:0001] */          X=0x07;
/* 015 [def:1801] [use:0010] */          ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6E84);
/* 017 [def:0001] [use:0001] */      case 0x6E86: L_6e86: //20 96 6E
/* 018 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x88;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6E86);
/* 021 [def:0001] [use:0001] */          PC = 0x6e96;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6E89: L_6e89: //2C 05 24
/* 001 [def:1101] [use:0001] */          ZN=ram[0x2405];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6E89);
/* 005 [def:0001] [use:0001] */      case 0x6E8C: L_6e8c: //10 37 A5
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x6E8C);
/* 009 [def:0001] [use:0001] */              PC = 0x6ec5;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E8C);
/* 002 [def:0001] [use:0001] */      case 0x6E8E: L_6e8e: //A5 76 29
/* 003 [def:0009] [use:0001] */          A=ram[0x0076];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6E8E);
/* 006 [def:0001] [use:0001] */      case 0x6E90: L_6e90: //29 04 F0
/* 007 [def:0009] [use:0008] */          A &= 0x04;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6E90);
/* 010 [def:0001] [use:0001] */      case 0x6E92: L_6e92: //F0 31 A2
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6E92);
/* 014 [def:0001] [use:0001] */              PC = 0x6ec5;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6E92);
/* 002 [def:0001] [use:0001] */      case 0x6E94: L_6e94: //A2 01 98
/* 003 [def:0001] [use:0001] */          X=0x01;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6E94);
/* 006 [def:0001] [use:0001] */      case 0x6E96: L_6e96: //98 38 65
/* 007 [def:0001] [use:0001] */          A=Y;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6E96);
/* 010 [def:0001] [use:0001] */      case 0x6E97: L_6e97: //38 65 10
/* 011 [def:2001] [use:0000] */          C = 1;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6E97);
/* 013 [def:0001] [use:0001] */      case 0x6E98: L_6e98: //65 10 85
/* 014 [def:b801] [use:6001] */          ADC(ram[0x0010]);
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6E98);
/* 016 [def:0001] [use:0001] */      case 0x6E9A: L_6e9a: //85 10 A9
/* 017 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6E9A);
/* 019 [def:0001] [use:0001] */      case 0x6E9C: L_6e9c: //A9 00 65
/* 020 [def:0009] [use:0000] */          A=0x00;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6E9C);
/* 023 [def:0001] [use:0001] */      case 0x6E9E: L_6e9e: //65 11 85
/* 024 [def:b801] [use:6001] */          ADC(ram[0x0011]);
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6E9E);
/* 026 [def:0001] [use:0001] */      case 0x6EA0: L_6ea0: //85 11 4C
/* 027 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6EA0);
/* 029 [def:0001] [use:0001] */      case 0x6EA2: L_6ea2: //4C 21 62
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6EA2);
/* 031 [def:0001] [use:0001] */          PC = 0x6221;
/*                           */          clockticks += 37; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6EA5: L_6ea5: //A5 79 38
/* 001 [def:0009] [use:0001] */          A=ram[0x0079];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6EA5);
/* 004 [def:0001] [use:0001] */      case 0x6EA7: L_6ea7: //38 E9 40
/* 005 [def:2001] [use:0000] */          C = 1;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6EA7);
/* 007 [def:0001] [use:0001] */      case 0x6EA8: L_6ea8: //E9 40 20
/* 008 [def:b809] [use:6009] */          SBC(0x40);
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6EA8);
/* 010 [def:0001] [use:0001] */      case 0x6EAA: L_6eaa: //20 C6 6E
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x6E;
/* 012 [def:0001] [use:0001] */          stack[S--] = 0xAC;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6EAA);
/* 014 [def:0001] [use:0001] */          PC = 0x6ec6;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6EAD: L_6ead: //98 4A A8
/* 001 [def:0001] [use:0001] */          A=Y;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6EAD);
/* 004 [def:0001] [use:0001] */      case 0x6EAE: L_6eae: //4A A8 A2
/* 005 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 006 [def:0009] [use:0008] */          A = A >> 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6EAE);
/* 009 [def:0001] [use:0001] */      case 0x6EAF: L_6eaf: //A8 A2 53
/* 010 [def:0021] [use:0008] */          Y=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6EAF);
/* 013 [def:0001] [use:0001] */      case 0x6EB0: L_6eb0: //A2 53 B9
/* 014 [def:0001] [use:0001] */          X=0x53;
/* 015 [def:1800] [use:0010] */  //      ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6EB0);
/* 017 [def:0001] [use:0001] */      case 0x6EB2: L_6eb2: //B9 BC 53
/* 018 [def:0009] [use:0021] */          A=ram[0x53BC + Y /* can't wrap */];
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6EB2);
/* 021 [def:0001] [use:0001] */      case 0x6EB5: L_6eb5: //0A 90 02
/* 022 [def:2001] [use:0008] */          C = A & 0x80;
/* 023 [def:0009] [use:0008] */          A = A << 1;
/* 024 [def:1801] [use:0008] */          ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6EB5);
/* 026 [def:0001] [use:0001] */      case 0x6EB6: L_6eb6: //90 02 E8
/* 027 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 028 [def:0001] [use:0001] */          {
/* 029 [def:0001] [use:0001] */              //trace_PC(0x6EB6);
/* 030 [def:0001] [use:0001] */              PC = 0x6eba;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6EB6);
/* 002 [def:0001] [use:0001] */      case 0x6EB8: L_6eb8: //E8 18 69
/* 003 [def:0011] [use:0010] */          X++;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6EB8);
/* 006 [def:0001] [use:0001] */      case 0x6EB9: L_6eb9: //18 69 C6
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6EB9);
/* 009 [def:0001] [use:0001] */      case 0x6EBA: L_6eba: //69 C6 85
/* 010 [def:b801] [use:6001] */          ADC(0xC6);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6EBA);
/* 012 [def:0001] [use:0001] */      case 0x6EBC: L_6ebc: //85 10 8A
/* 013 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x6EBC);
/* 015 [def:0001] [use:0001] */      case 0x6EBE: L_6ebe: //8A 69 00
/* 016 [def:0001] [use:0001] */          A=X;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6EBE);
/* 019 [def:0001] [use:0001] */      case 0x6EBF: L_6ebf: //69 00 85
/* 020 [def:b801] [use:6001] */          ADC(0x00);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6EBF);
/* 022 [def:0001] [use:0001] */      case 0x6EC1: L_6ec1: //85 11 A2
/* 023 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6EC1);
/* 025 [def:0001] [use:0001] */      case 0x6EC3: L_6ec3: //A2 00 60
/* 026 [def:0001] [use:0001] */          X=0x00;
/* 027 [def:1801] [use:0010] */          ZN = X;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x6EC3);
/* 029 [def:0001] [use:0001] */      case 0x6EC5: L_6ec5: //60 4A 85
/* 030 [def:0001] [use:0001] */          //trace_PC(0x6EC5);
/* 031 [def:0001] [use:0001] */          PC=stack[++S];
/* 032 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 033 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 42; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6EC6: L_6ec6: //4A 85 10
/* 001 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 002 [def:0009] [use:0008] */          A = A >> 1;
/* 003 [def:1800] [use:0008] */  //      ZN = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6EC6);
/* 005 [def:0001] [use:0001] */      case 0x6EC7: L_6ec7: //85 10 4A
/* 006 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6EC7);
/* 008 [def:0001] [use:0001] */      case 0x6EC9: L_6ec9: //4A 4A 4A
/* 009 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 010 [def:0009] [use:0008] */          A = A >> 1;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6EC9);
/* 013 [def:0001] [use:0001] */      case 0x6ECA: L_6eca: //4A 4A 4A
/* 014 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 015 [def:0009] [use:0008] */          A = A >> 1;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6ECA);
/* 018 [def:0001] [use:0001] */      case 0x6ECB: L_6ecb: //4A 4A A8
/* 019 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 020 [def:0009] [use:0008] */          A = A >> 1;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6ECB);
/* 023 [def:0001] [use:0001] */      case 0x6ECC: L_6ecc: //4A A8 B9
/* 024 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 025 [def:0009] [use:0008] */          A = A >> 1;
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6ECC);
/* 028 [def:0001] [use:0001] */      case 0x6ECD: L_6ecd: //A8 B9 EE
/* 029 [def:0021] [use:0008] */          Y=A;
/* 030 [def:1800] [use:0008] */  //      ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x6ECD);
/* 032 [def:0001] [use:0001] */      case 0x6ECE: L_6ece: //B9 EE 6E
/* 033 [def:0009] [use:0021] */          A=ram[0x6EEE + Y /* can't wrap */];
/* 034 [def:1800] [use:0008] */  //      ZN = A;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x6ECE);
/* 036 [def:0001] [use:0001] */      case 0x6ED1: L_6ed1: //0A 85 12
/* 037 [def:2001] [use:0008] */          C = A & 0x80;
/* 038 [def:0009] [use:0008] */          A = A << 1;
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6ED1);
/* 041 [def:0001] [use:0001] */      case 0x6ED2: L_6ed2: //85 12 A5
/* 042 [def:0001] [use:0008] */          ram[0x0012] = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x6ED2);
/* 044 [def:0001] [use:0001] */      case 0x6ED4: L_6ed4: //A5 10 29
/* 045 [def:0009] [use:0001] */          A=ram[0x0010];
/* 046 [def:1800] [use:0008] */  //      ZN = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x6ED4);
/* 048 [def:0001] [use:0001] */      case 0x6ED6: L_6ed6: //29 0E 90
/* 049 [def:0009] [use:0008] */          A &= 0x0E;
/* 050 [def:1801] [use:0008] */          ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x6ED6);
/* 052 [def:0001] [use:0001] */      case 0x6ED8: L_6ed8: //90 04 49
/* 053 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 054 [def:0001] [use:0001] */          {
/* 055 [def:0001] [use:0001] */              //trace_PC(0x6ED8);
/* 056 [def:0001] [use:0001] */              PC = 0x6ede;
/*                           */              clockticks += 31;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6ED8);
/* 002 [def:0001] [use:0001] */      case 0x6EDA: L_6eda: //49 0E 69
/* 003 [def:0009] [use:0008] */          A ^= 0x0E;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6EDA);
/* 006 [def:0001] [use:0001] */      case 0x6EDC: L_6edc: //69 01 A8
/* 007 [def:b801] [use:6001] */          ADC(0x01);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6EDC);
/* 009 [def:0001] [use:0001] */      case 0x6EDE: L_6ede: //A8 A5 12
/* 010 [def:0021] [use:0008] */          Y=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6EDE);
/* 013 [def:0001] [use:0001] */      case 0x6EDF: L_6edf: //A5 12 29
/* 014 [def:0009] [use:0001] */          A=ram[0x0012];
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x6EDF);
/* 017 [def:0001] [use:0001] */      case 0x6EE1: L_6ee1: //29 04 85
/* 018 [def:0009] [use:0008] */          A &= 0x04;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6EE1);
/* 021 [def:0001] [use:0001] */      case 0x6EE3: L_6ee3: //85 09 06
/* 022 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6EE3);
/* 024 [def:0001] [use:0001] */      case 0x6EE5: L_6ee5: //06 12 A5
/* 025 [def:0101] [use:0001] */          ZN=ram[0x0012];
/* 026 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 027 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 028 [def:0001] [use:1800] */          ram[0x0012] = ZN; /* Because at this point it actually has the correct value in it */
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6EE5);
/* 030 [def:0001] [use:0001] */      case 0x6EE7: L_6ee7: //A5 12 29
/* 031 [def:0009] [use:0001] */          A=ram[0x0012];
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6EE7);
/* 034 [def:0001] [use:0001] */      case 0x6EE9: L_6ee9: //29 04 85
/* 035 [def:0009] [use:0008] */          A &= 0x04;
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x6EE9);
/* 038 [def:0001] [use:0001] */      case 0x6EEB: L_6eeb: //85 0A 60
/* 039 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x6EEB);
/* 041 [def:0001] [use:0001] */      case 0x6EED: L_6eed: //60 00 A3
/* 042 [def:0001] [use:0001] */          //trace_PC(0x6EED);
/* 043 [def:0001] [use:0001] */          PC=stack[++S];
/* 044 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 045 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 65; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6EF6: L_6ef6: //46 10 A6
/* 001 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 003 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 004 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6EF6);
/* 006 [def:0001] [use:0001] */      case 0x6EF8: L_6ef8: //A6 22 F0
/* 007 [def:0001] [use:0001] */          X=ram[0x0022];
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6EF8);
/* 010 [def:0001] [use:0001] */      case 0x6EFA: L_6efa: //F0 59 A6
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x6EFA);
/* 014 [def:0001] [use:0001] */              PC = 0x6f55;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6EFA);
/* 002 [def:0001] [use:0001] */      case 0x6EFC: L_6efc: //A6 A2 D0
/* 003 [def:0001] [use:0001] */          X=ram[0x00A2];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6EFC);
/* 006 [def:0001] [use:0001] */      case 0x6EFE: L_6efe: //D0 18 A5
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6EFE);
/* 010 [def:0001] [use:0001] */              PC = 0x6f18;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6EFE);
/* 002 [def:0001] [use:0001] */      case 0x6F00: L_6f00: //A5 7E F0
/* 003 [def:0009] [use:0001] */          A=ram[0x007E];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F00);
/* 006 [def:0001] [use:0001] */      case 0x6F02: L_6f02: //F0 09 A0
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F02);
/* 010 [def:0001] [use:0001] */              PC = 0x6f0d;
/*                           */              clockticks += 21;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F02);
/* 002 [def:0001] [use:0001] */      case 0x6F04: L_6f04: //A0 2F 20
/* 003 [def:0021] [use:0000] */          Y=0x2F;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F04);
/* 006 [def:0001] [use:0001] */      case 0x6F06: L_6f06: //20 16 77
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x08;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6F06);
/* 010 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 29; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F09: L_6f09: //86 7E F0
/* 001 [def:0001] [use:0001] */          ram[0x007E] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6F09);
/* 003 [def:0001] [use:0001] */      case 0x6F0B: L_6f0b: //F0 0B A5
/* 004 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 005 [def:0001] [use:0001] */          {
/* 006 [def:0001] [use:0001] */              //trace_PC(0x6F0B);
/* 007 [def:0001] [use:0001] */              PC = 0x6f18;
/*                           */              clockticks += 5;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F0B);
/* 002 [def:0001] [use:0001] */      case 0x6F0D: L_6f0d: //A5 DD F0
/* 003 [def:0009] [use:0001] */          A=ram[0x00DD];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F0D);
/* 006 [def:0001] [use:0001] */      case 0x6F0F: L_6f0f: //F0 07 A0
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F0F);
/* 010 [def:0001] [use:0001] */              PC = 0x6f18;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F0F);
/* 002 [def:0001] [use:0001] */      case 0x6F11: L_6f11: //A0 5F 20
/* 003 [def:0021] [use:0000] */          Y=0x5F;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F11);
/* 006 [def:0001] [use:0001] */      case 0x6F13: L_6f13: //20 16 77
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x15;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6F13);
/* 010 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F16: L_6f16: //86 DD AD
/* 001 [def:0001] [use:0001] */          ram[0x00DD] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6F16);
/* 003 [def:0001] [use:0001] */      case 0x6F18: L_6f18: //AD 19 02
/* 004 [def:0009] [use:0001] */          A=ram[0x0219];
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6F18);
/* 007 [def:0001] [use:0001] */      case 0x6F1B: L_6f1b: //30 14 F0
/* 008 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6F1B);
/* 011 [def:0001] [use:0001] */              PC = 0x6f31;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F1B);
/* 002 [def:0001] [use:0001] */      case 0x6F1D: L_6f1d: //F0 12 0E
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x6F1D);
/* 006 [def:0001] [use:0001] */              PC = 0x6f31;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F1D);
/* 002 [def:0001] [use:0001] */      case 0x6F1F: L_6f1f: //0E 05 24
/* 003 [def:0101] [use:0001] */          ZN=ram[0x2405];
/* 004 [def:2001] [use:0100] */          C = ZN & 0x80;
/* 005 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 006 [def:0001] [use:0100] */          ram[0x2405] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6F1F);
/* 008 [def:0001] [use:0001] */      case 0x6F22: L_6f22: //66 10 AD
/* 009 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 010 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 011 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 012 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 013 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 014 [def:0001] [use:0100] */          ram[0x0010] = ZN;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6F22);
/* 016 [def:0001] [use:0001] */      case 0x6F24: L_6f24: //AD E7 02
/* 017 [def:0009] [use:0001] */          A=ram[0x02E7];
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6F24);
/* 020 [def:0001] [use:0001] */      case 0x6F27: L_6f27: //F0 08 A5
/* 021 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x6F27);
/* 024 [def:0001] [use:0001] */              PC = 0x6f31;
/*                           */              clockticks += 28;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F27);
/* 002 [def:0001] [use:0001] */      case 0x6F29: L_6f29: //A5 83 F0
/* 003 [def:0009] [use:0001] */          A=ram[0x0083];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F29);
/* 006 [def:0001] [use:0001] */      case 0x6F2B: L_6f2b: //F0 0B C6
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F2B);
/* 010 [def:0001] [use:0001] */              PC = 0x6f38;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F2B);
/* 002 [def:0001] [use:0001] */      case 0x6F2D: L_6f2d: //C6 83 D0
/* 003 [def:0001] [use:0001] */          ZN=ram[0x0083]-1;
/* 004 [def:0001] [use:0001] */          ram[0x0083] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F2D);
/* 006 [def:0001] [use:0001] */      case 0x6F2F: L_6f2f: //D0 1C AD
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F2F);
/* 010 [def:0001] [use:0001] */              PC = 0x6f4d;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F2F);
/* 002 [def:0001] [use:0001] */      case 0x6F31: L_6f31: //AD ED 02
/* 003 [def:0009] [use:0001] */          A=ram[0x02ED];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F31);
/* 006 [def:0001] [use:0001] */      case 0x6F34: L_6f34: //85 84 10
/* 007 [def:0001] [use:0008] */          ram[0x0084] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6F34);
/* 009 [def:0001] [use:0001] */      case 0x6F36: L_6f36: //10 15 C6
/* 010 [def:0001] [use:1001] */          if (ZN < 0)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x6F36);
/* 013 [def:0001] [use:0001] */              PC = 0x6f4d;
/*                           */              clockticks += 48;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F36);
/* 002 [def:0001] [use:0001] */      case 0x6F38: L_6f38: //C6 84 D0
/* 003 [def:0001] [use:0001] */          ZN=ram[0x0084]-1;
/* 004 [def:0001] [use:0001] */          ram[0x0084] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F38);
/* 006 [def:0001] [use:0001] */      case 0x6F3A: L_6f3a: //D0 11 A9
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F3A);
/* 010 [def:0001] [use:0001] */              PC = 0x6f4d;
/*                           */              clockticks += 55;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F3A);
/* 002 [def:0001] [use:0001] */      case 0x6F3C: L_6f3c: //A9 04 85
/* 003 [def:0009] [use:0000] */          A=0x04;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F3C);
/* 006 [def:0001] [use:0001] */      case 0x6F3E: L_6f3e: //85 83 E6
/* 007 [def:0001] [use:0008] */          ram[0x0083] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6F3E);
/* 009 [def:0001] [use:0001] */      case 0x6F40: L_6f40: //E6 82 A5
/* 010 [def:1801] [use:0001] */          ZN=++ram[0x0082];
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6F40);
/* 012 [def:0001] [use:0001] */      case 0x6F42: L_6f42: //A5 82 29
/* 013 [def:0009] [use:0001] */          A=ram[0x0082];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6F42);
/* 016 [def:0001] [use:0001] */      case 0x6F44: L_6f44: //29 01 AA
/* 017 [def:0009] [use:0008] */          A &= 0x01;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x6F44);
/* 020 [def:0001] [use:0001] */      case 0x6F46: L_6f46: //AA BC 60
/* 021 [def:0011] [use:0008] */          X=A;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x6F46);
/* 024 [def:0001] [use:0001] */      case 0x6F47: L_6f47: //BC 60 6F
/* 025 [def:0021] [use:0011] */          Y=ram[(unsigned short)(0x6F60 + X)];
/* 026 [def:1801] [use:0020] */          ZN = Y;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x6F47);
/* 028 [def:0001] [use:0001] */      case 0x6F4A: L_6f4a: //20 13 77
/* 029 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 030 [def:0001] [use:0001] */          stack[S--] = 0x4C;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x6F4A);
/* 032 [def:0001] [use:0001] */          PC = 0x7713;
/*                           */          clockticks += 82; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F4D: L_6f4d: //A5 7F AA
/* 001 [def:0009] [use:0001] */          A=ram[0x007F];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6F4D);
/* 004 [def:0001] [use:0001] */      case 0x6F4F: L_6f4f: //AA 29 3F
/* 005 [def:0011] [use:0008] */          X=A;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6F4F);
/* 008 [def:0001] [use:0001] */      case 0x6F50: L_6f50: //29 3F F0
/* 009 [def:0009] [use:0008] */          A &= 0x3F;
/* 010 [def:1801] [use:0008] */          ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6F50);
/* 012 [def:0001] [use:0001] */      case 0x6F52: L_6f52: //F0 01 CA
/* 013 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x6F52);
/* 016 [def:0001] [use:0001] */              PC = 0x6f55;
/*                           */              clockticks += 11;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F52);
/* 002 [def:0001] [use:0001] */      case 0x6F54: L_6f54: //CA 86 7F
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F54);
/* 006 [def:0001] [use:0001] */      case 0x6F55: L_6f55: //86 7F 8E
/* 007 [def:0001] [use:0001] */          ram[0x007F] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6F55);
/* 009 [def:0001] [use:0001] */      case 0x6F57: L_6f57: //8E 00 36
/* 010 [def:0001] [use:0001] */          ram[0x3600] = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6F57);
/* 012 [def:0001] [use:0001] */      case 0x6F5A: L_6f5a: //A5 10 8D
/* 013 [def:0009] [use:0001] */          A=ram[0x0010];
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6F5A);
/* 016 [def:0001] [use:0001] */      case 0x6F5C: L_6f5c: //8D 03 3C
/* 017 [def:0001] [use:0008] */          ram[0x3C03] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6F5C);
/* 019 [def:0001] [use:0001] */      case 0x6F5F: L_6f5f: //60 07 0F
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6F5F);
/* 021 [def:0001] [use:0001] */          PC=stack[++S];
/* 022 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 023 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 31; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F62: L_6f62: //86 0E A9
/* 001 [def:0001] [use:0001] */          ram[0x000E] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x6F62);
/* 003 [def:0001] [use:0001] */      case 0x6F64: L_6f64: //A9 50 8D
/* 004 [def:0009] [use:0000] */          A=0x50;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6F64);
/* 007 [def:0001] [use:0001] */      case 0x6F66: L_6f66: //8D EA 02
/* 008 [def:0001] [use:0008] */          ram[0x02EA] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6F66);
/* 010 [def:0001] [use:0001] */      case 0x6F69: L_6f69: //B9 00 02
/* 011 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6F69);
/* 014 [def:0001] [use:0001] */      case 0x6F6C: L_6f6c: //29 78 0A
/* 015 [def:0009] [use:0008] */          A &= 0x78;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6F6C);
/* 018 [def:0001] [use:0001] */      case 0x6F6E: L_6f6e: //0A 10 03
/* 019 [def:2001] [use:0008] */          C = A & 0x80;
/* 020 [def:0009] [use:0008] */          A = A << 1;
/* 021 [def:1801] [use:0008] */          ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x6F6E);
/* 023 [def:0001] [use:0001] */      case 0x6F6F: L_6f6f: //10 03 4C
/* 024 [def:0001] [use:1001] */          if (ZN < 0)
/* 025 [def:0001] [use:0001] */          {
/* 026 [def:0001] [use:0001] */              //trace_PC(0x6F6F);
/* 027 [def:0001] [use:0001] */              PC = 0x6f74;
/*                           */              clockticks += 21;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F6F);
/* 002 [def:0001] [use:0001] */      case 0x6F71: L_6f71: //4C 00 48
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6F71);
/* 004 [def:0001] [use:0001] */          PC = 0x4800;
/*                           */          clockticks += 23; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F74: L_6f74: //4A 85 0F
/* 001 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 002 [def:0009] [use:0008] */          A = A >> 1;
/* 003 [def:1800] [use:0008] */  //      ZN = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6F74);
/* 005 [def:0001] [use:0001] */      case 0x6F75: L_6f75: //85 0F B9
/* 006 [def:0001] [use:0008] */          ram[0x000F] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6F75);
/* 008 [def:0001] [use:0001] */      case 0x6F77: L_6f77: //B9 00 02
/* 009 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6F77);
/* 012 [def:0001] [use:0001] */      case 0x6F7A: L_6f7a: //29 07 4A
/* 013 [def:0009] [use:0008] */          A &= 0x07;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x6F7A);
/* 016 [def:0001] [use:0001] */      case 0x6F7C: L_6f7c: //4A AA F0
/* 017 [def:2001] [use:0008] */          C = A & 0x01;
/* 018 [def:0009] [use:0008] */          A = A >> 1;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6F7C);
/* 021 [def:0001] [use:0001] */      case 0x6F7D: L_6f7d: //AA F0 02
/* 022 [def:0011] [use:0008] */          X=A;
/* 023 [def:1801] [use:0008] */          ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6F7D);
/* 025 [def:0001] [use:0001] */      case 0x6F7E: L_6f7e: //F0 02 05
/* 026 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x6F7E);
/* 029 [def:0001] [use:0001] */              PC = 0x6f82;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F7E);
/* 002 [def:0001] [use:0001] */      case 0x6F80: L_6f80: //05 0F 99
/* 003 [def:0009] [use:0009] */          A|=ram[0x000F];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F80);
/* 006 [def:0001] [use:0001] */      case 0x6F82: L_6f82: //99 00 02
/* 007 [def:0001] [use:0021] */          ram[(unsigned short)(0x0200 + Y)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6F82);
/* 009 [def:0001] [use:0001] */      case 0x6F85: L_6f85: //A5 22 F0
/* 010 [def:0009] [use:0001] */          A=ram[0x0022];
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6F85);
/* 013 [def:0001] [use:0001] */      case 0x6F87: L_6f87: //F0 0F A5
/* 014 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x6F87);
/* 017 [def:0001] [use:0001] */              PC = 0x6f98;
/*                           */              clockticks += 31;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F87);
/* 002 [def:0001] [use:0001] */      case 0x6F89: L_6f89: //A5 0E F0
/* 003 [def:0009] [use:0001] */          A=ram[0x000E];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F89);
/* 006 [def:0001] [use:0001] */      case 0x6F8B: L_6f8b: //F0 04 C9
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x6F8B);
/* 010 [def:0001] [use:0001] */              PC = 0x6f91;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F8B);
/* 002 [def:0001] [use:0001] */      case 0x6F8D: L_6f8d: //C9 04 90
/* 003 [def:0101] [use:0000] */          ZN=0x04;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x6F8D);
/* 007 [def:0001] [use:0001] */      case 0x6F8F: L_6f8f: //90 07 BD
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x6F8F);
/* 011 [def:0001] [use:0001] */              PC = 0x6f98;
/*                           */              clockticks += 41;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F8F);
/* 002 [def:0001] [use:0001] */      case 0x6F91: L_6f91: //BD 75 4D
/* 003 [def:0009] [use:0011] */          A=ram[0x4D75 + X /* can't wrap */];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F91);
/* 006 [def:0001] [use:0001] */      case 0x6F94: L_6f94: //18 20 44
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6F94);
/* 009 [def:0001] [use:0001] */      case 0x6F95: L_6f95: //20 44 6C
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x97;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6F95);
/* 013 [def:0001] [use:0001] */          PC = 0x6c44;
/*                           */          clockticks += 52; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6F98: L_6f98: //BE 00 02
/* 001 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x0200 + Y)];
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6F98);
/* 004 [def:0001] [use:0001] */      case 0x6F9B: L_6f9b: //F0 34 20
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6F9B);
/* 008 [def:0001] [use:0001] */              PC = 0x6fd1;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6F9B);
/* 002 [def:0001] [use:0001] */      case 0x6F9D: L_6f9d: //20 50 6D
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x9F;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6F9D);
/* 006 [def:0001] [use:0001] */          PC = 0x6d50;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FA0: L_6fa0: //30 2F EE
/* 001 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6FA0);
/* 004 [def:0001] [use:0001] */              PC = 0x6fd1;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6FA0);
/* 002 [def:0001] [use:0001] */      case 0x6FA2: L_6fa2: //EE E7 02
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6FA2);
/* 005 [def:0001] [use:0001] */      case 0x6FA5: L_6fa5: //20 EB 61
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 007 [def:0001] [use:0001] */          stack[S--] = 0xA7;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6FA5);
/* 009 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FA8: L_6fa8: //20 3B 6A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xAA;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FA8);
/* 004 [def:0001] [use:0001] */          PC = 0x6a3b;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FAB: L_6fab: //BD 21 02
/* 001 [def:0009] [use:0011] */          A=ram[0x0221 + X /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FAB);
/* 004 [def:0001] [use:0001] */      case 0x6FAE: L_6fae: //29 1F 0A
/* 005 [def:0009] [use:0008] */          A &= 0x1F;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6FAE);
/* 008 [def:0001] [use:0001] */      case 0x6FB0: L_6fb0: //0A 5D A5
/* 009 [def:2001] [use:0008] */          C = A & 0x80;
/* 010 [def:0009] [use:0008] */          A = A << 1;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6FB0);
/* 013 [def:0001] [use:0001] */      case 0x6FB1: L_6fb1: //5D A5 02
/* 014 [def:0001] [use:0011] */          ZN=ram[(unsigned short)(0x02A5 + X)];
/* 015 [def:0001] [use:0001] */          A ^= ZN;
/* 016 [def:1801] [use:0008] */          ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6FB1);
/* 018 [def:0001] [use:0001] */      case 0x6FB4: L_6fb4: //9D A5 02
/* 019 [def:0001] [use:0019] */          ram[0x02A5 + X /* can't wrap */] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6FB4);
/* 021 [def:0001] [use:0001] */      case 0x6FB7: L_6fb7: //20 52 6D
/* 022 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 023 [def:0001] [use:0001] */          stack[S--] = 0xB9;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6FB7);
/* 025 [def:0001] [use:0001] */          PC = 0x6d52;
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FBA: L_6fba: //30 15 EE
/* 001 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x6FBA);
/* 004 [def:0001] [use:0001] */              PC = 0x6fd1;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6FBA);
/* 002 [def:0001] [use:0001] */      case 0x6FBC: L_6fbc: //EE E7 02
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x02E7];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6FBC);
/* 005 [def:0001] [use:0001] */      case 0x6FBF: L_6fbf: //20 EB 61
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 007 [def:0001] [use:0001] */          stack[S--] = 0xC1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x6FBF);
/* 009 [def:0001] [use:0001] */          PC = 0x61eb;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FC2: L_6fc2: //20 3B 6A
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xC4;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FC2);
/* 004 [def:0001] [use:0001] */          PC = 0x6a3b;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FC5: L_6fc5: //BD 42 02
/* 001 [def:0009] [use:0011] */          A=ram[0x0242 + X /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FC5);
/* 004 [def:0001] [use:0001] */      case 0x6FC8: L_6fc8: //29 1F 0A
/* 005 [def:0009] [use:0008] */          A &= 0x1F;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6FC8);
/* 008 [def:0001] [use:0001] */      case 0x6FCA: L_6fca: //0A 5D C6
/* 009 [def:2001] [use:0008] */          C = A & 0x80;
/* 010 [def:0009] [use:0008] */          A = A << 1;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x6FCA);
/* 013 [def:0001] [use:0001] */      case 0x6FCB: L_6fcb: //5D C6 02
/* 014 [def:0001] [use:0011] */          ZN=ram[(unsigned short)(0x02C6 + X)];
/* 015 [def:0001] [use:0001] */          A ^= ZN;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6FCB);
/* 018 [def:0001] [use:0001] */      case 0x6FCE: L_6fce: //9D C6 02
/* 019 [def:0001] [use:0019] */          ram[0x02C6 + X /* can't wrap */] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x6FCE);
/* 021 [def:0001] [use:0001] */      case 0x6FD1: L_6fd1: //A6 0E 60
/* 022 [def:0001] [use:0001] */          X=ram[0x000E];
/* 023 [def:1801] [use:0010] */          ZN = X;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x6FD1);
/* 025 [def:0001] [use:0001] */      case 0x6FD3: L_6fd3: //60 A5 22
/* 026 [def:0001] [use:0001] */          //trace_PC(0x6FD3);
/* 027 [def:0001] [use:0001] */          PC=stack[++S];
/* 028 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 029 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FD4: L_6fd4: //A5 22 10
/* 001 [def:0009] [use:0001] */          A=ram[0x0022];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FD4);
/* 004 [def:0001] [use:0001] */      case 0x6FD6: L_6fd6: //10 4D 85
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x6FD6);
/* 008 [def:0001] [use:0001] */              PC = 0x7025;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6FD6);
/* 002 [def:0001] [use:0001] */      case 0x6FD8: L_6fd8: //85 77 85
/* 003 [def:0001] [use:0008] */          ram[0x0077] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x6FD8);
/* 005 [def:0001] [use:0001] */      case 0x6FDA: L_6fda: //85 42 85
/* 006 [def:0001] [use:0008] */          ram[0x0042] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6FDA);
/* 008 [def:0001] [use:0001] */      case 0x6FDC: L_6fdc: //85 43 85
/* 009 [def:0001] [use:0008] */          ram[0x0043] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x6FDC);
/* 011 [def:0001] [use:0001] */      case 0x6FDE: L_6fde: //85 CE 20
/* 012 [def:0001] [use:0008] */          ram[0x00CE] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6FDE);
/* 014 [def:0001] [use:0001] */      case 0x6FE0: L_6fe0: //20 44 78
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x6F;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0xE2;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6FE0);
/* 018 [def:0001] [use:0001] */          PC = 0x7844;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x6FE3: L_6fe3: //A2 03 A0
/* 001 [def:0001] [use:0001] */          X=0x03;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x6FE3);
/* 004 [def:0001] [use:0001] */      case 0x6FE5: L_6fe5: //A0 00 B9
/* 005 [def:0021] [use:0000] */          Y=0x00;
/* 006 [def:1800] [use:0020] */  //      ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x6FE5);
/* 008 [def:0001] [use:0001] */      case 0x6FE7: L_6fe7: //B9 23 00
/* 009 [def:0009] [use:0021] */          A=ram[0x0023 + Y /* can't wrap */];
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x6FE7);
/* 012 [def:0001] [use:0001] */      case 0x6FEA: L_6fea: //D5 62 B9
/* 013 [def:0101] [use:0011] */          ZN=(0x0062 + X)&0xFF;
/* 014 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 015 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 016 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x6FEA);
/* 018 [def:0001] [use:0001] */      case 0x6FEC: L_6fec: //B9 24 00
/* 019 [def:0009] [use:0021] */          A=ram[0x0024 + Y /* can't wrap */];
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x6FEC);
/* 022 [def:0001] [use:0001] */      case 0x6FEF: L_6fef: //F5 63 B9
/* 023 [def:0101] [use:0011] */          ZN=(0x0063 + X)&0xFF;
/* 024 [def:b809] [use:6109] */          SBC(ram[ZN]); // beware ZN expansion
/* 025 [def:0001] [use:0001] */          //trace_PC(0x6FEF);
/* 026 [def:0001] [use:0001] */      case 0x6FF1: L_6ff1: //B9 25 00
/* 027 [def:0009] [use:0021] */          A=ram[0x0025 + Y /* can't wrap */];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x6FF1);
/* 030 [def:0001] [use:0001] */      case 0x6FF4: L_6ff4: //F5 64 90
/* 031 [def:0101] [use:0011] */          ZN=(0x0064 + X)&0xFF;
/* 032 [def:b809] [use:6109] */          SBC(ram[ZN]); // beware ZN expansion
/* 033 [def:0001] [use:0001] */          //trace_PC(0x6FF4);
/* 034 [def:0001] [use:0001] */      case 0x6FF6: L_6ff6: //90 2E C8
/* 035 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 036 [def:0001] [use:0001] */          {
/* 037 [def:0001] [use:0001] */              //trace_PC(0x6FF6);
/* 038 [def:0001] [use:0001] */              PC = 0x7026;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6FF6);
/* 002 [def:0001] [use:0001] */      case 0x6FF8: L_6ff8: //C8 C8 C8
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6FF8);
/* 006 [def:0001] [use:0001] */      case 0x6FF9: L_6ff9: //C8 C8 C0
/* 007 [def:0021] [use:0020] */          Y++;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x6FF9);
/* 010 [def:0001] [use:0001] */      case 0x6FFA: L_6ffa: //C8 C0 1E
/* 011 [def:0021] [use:0020] */          Y++;
/* 012 [def:1800] [use:0020] */  //      ZN = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x6FFA);
/* 014 [def:0001] [use:0001] */      case 0x6FFB: L_6ffb: //C0 1E 90
/* 015 [def:0101] [use:0001] */          ZN=0x1E;
/* 016 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 017 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x6FFB);
/* 019 [def:0001] [use:0001] */      case 0x6FFD: L_6ffd: //90 E8 CA
/* 020 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x6FFD);
/* 023 [def:0001] [use:0001] */              PC = 0x6fe7;
/*                           */              clockticks += 44;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x6FFD);
/* 002 [def:0001] [use:0001] */      case 0x6FFF: L_6fff: //CA CA CA
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x6FFF);
/* 006 [def:0001] [use:0001] */      case 0x7000: L_7000: //CA CA 10
/* 007 [def:0011] [use:0010] */          X--;
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7000);
/* 010 [def:0001] [use:0001] */      case 0x7001: L_7001: //CA 10 E1
/* 011 [def:0011] [use:0010] */          X--;
/* 012 [def:1801] [use:0010] */          ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7001);
/* 014 [def:0001] [use:0001] */      case 0x7002: L_7002: //10 E1 A5
/* 015 [def:0001] [use:1001] */          if (ZN < 0)
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7002);
/* 018 [def:0001] [use:0001] */              PC = 0x6fe5;
/*                           */              clockticks += 52;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7002);
/* 002 [def:0001] [use:0001] */      case 0x7004: L_7004: //A5 43 30
/* 003 [def:0009] [use:0001] */          A=ram[0x0043];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7004);
/* 006 [def:0001] [use:0001] */      case 0x7006: L_7006: //30 0E C5
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7006);
/* 010 [def:0001] [use:0001] */              PC = 0x7016;
/*                           */              clockticks += 57;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7006);
/* 002 [def:0001] [use:0001] */      case 0x7016: L_7016: //A6 CE 30
/* 003 [def:0001] [use:0001] */          X=ram[0x00CE];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7016);
/* 006 [def:0001] [use:0001] */      case 0x7018: L_7018: //30 05 A0
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7018);
/* 010 [def:0001] [use:0001] */              PC = 0x701f;
/*                           */              clockticks += 62;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7018);
/* 002 [def:0001] [use:0001] */      case 0x701A: L_701a: //A0 4F 20
/* 003 [def:0021] [use:0000] */          Y=0x4F;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x701A);
/* 006 [def:0001] [use:0001] */      case 0x701C: L_701c: //20 16 77
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x1E;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x701C);
/* 010 [def:0001] [use:0001] */          PC = 0x7716;
/*                           */          clockticks += 70; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x701F: L_701f: //A9 00 85
/* 001 [def:0009] [use:0000] */          A=0x00;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x701F);
/* 004 [def:0001] [use:0001] */      case 0x7021: L_7021: //85 22 85
/* 005 [def:0001] [use:0008] */          ram[0x0022] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7021);
/* 007 [def:0001] [use:0001] */      case 0x7023: L_7023: //85 41 60
/* 008 [def:0001] [use:0008] */          ram[0x0041] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7023);
/* 010 [def:0001] [use:0001] */      case 0x7025: L_7025: //60 86 0C
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7025);
/* 012 [def:0001] [use:0001] */          PC=stack[++S];
/* 013 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 014 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 13; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7026: L_7026: //86 0C 8A
/* 001 [def:0001] [use:0001] */          ram[0x000C] = X;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x7026);
/* 003 [def:0001] [use:0001] */      case 0x7028: L_7028: //8A 4A AA
/* 004 [def:0001] [use:0001] */          A=X;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7028);
/* 007 [def:0001] [use:0001] */      case 0x7029: L_7029: //4A AA 94
/* 008 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 009 [def:0009] [use:0008] */          A = A >> 1;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7029);
/* 012 [def:0001] [use:0001] */      case 0x702A: L_702a: //AA 94 42
/* 013 [def:0011] [use:0008] */          X=A;
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x702A);
/* 016 [def:0001] [use:0001] */      case 0x702B: L_702b: //94 42 84
/* 017 [def:0001] [use:0011] */          temp=(0x0042 + X)&0xFF;
/* 018 [def:0001] [use:0001] */          ram[temp] = Y;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x702B);
/* 020 [def:0001] [use:0001] */      case 0x702D: L_702d: //84 10 C4
/* 021 [def:0001] [use:0020] */          ram[0x0010] = Y;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x702D);
/* 023 [def:0001] [use:0001] */      case 0x702F: L_702f: //C4 CE B0
/* 024 [def:0001] [use:0001] */          ZN=ram[0x00CE];
/* 025 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 026 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x702F);
/* 028 [def:0001] [use:0001] */      case 0x7031: L_7031: //B0 26 84
/* 029 [def:0001] [use:2001] */          if (C)
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x7031);
/* 032 [def:0001] [use:0001] */              PC = 0x7059;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7031);
/* 002 [def:0001] [use:0001] */      case 0x7033: L_7033: //84 CE A9
/* 003 [def:0001] [use:0020] */          ram[0x00CE] = Y;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7033);
/* 005 [def:0001] [use:0001] */      case 0x7035: L_7035: //A9 00 85
/* 006 [def:0009] [use:0000] */          A=0x00;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7035);
/* 009 [def:0001] [use:0001] */      case 0x7037: L_7037: //85 11 98
/* 010 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7037);
/* 012 [def:0001] [use:0001] */      case 0x7039: L_7039: //98 38 E9
/* 013 [def:0001] [use:0001] */          A=Y;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7039);
/* 016 [def:0001] [use:0001] */      case 0x703A: L_703a: //38 E9 03
/* 017 [def:2001] [use:0000] */          C = 1;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x703A);
/* 019 [def:0001] [use:0001] */      case 0x703B: L_703b: //E9 03 90
/* 020 [def:b809] [use:6009] */          SBC(0x03);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x703B);
/* 022 [def:0001] [use:0001] */      case 0x703D: L_703d: //90 04 E6
/* 023 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 024 [def:0001] [use:0001] */          {
/* 025 [def:0001] [use:0001] */              //trace_PC(0x703D);
/* 026 [def:0001] [use:0001] */              PC = 0x7043;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x703D);
/* 002 [def:0001] [use:0001] */      case 0x7043: L_7043: //A5 11 49
/* 003 [def:0009] [use:0001] */          A=ram[0x0011];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7043);
/* 006 [def:0001] [use:0001] */      case 0x7045: L_7045: //49 FF 69
/* 007 [def:0009] [use:0008] */          A ^= 0xFF;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7045);
/* 010 [def:0001] [use:0001] */      case 0x7047: L_7047: //69 04 85
/* 011 [def:b801] [use:6001] */          ADC(0x04);
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7047);
/* 013 [def:0001] [use:0001] */      case 0x7049: L_7049: //85 11 06
/* 014 [def:0001] [use:0008] */          ram[0x0011] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7049);
/* 016 [def:0001] [use:0001] */      case 0x704B: L_704b: //06 11 65
/* 017 [def:0101] [use:0001] */          ZN=ram[0x0011];
/* 018 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 019 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 020 [def:0001] [use:1800] */          ram[0x0011] = ZN; /* Because at this point it actually has the correct value in it */
/* 021 [def:0001] [use:0001] */          //trace_PC(0x704B);
/* 022 [def:0001] [use:0001] */      case 0x704D: L_704d: //65 11 06
/* 023 [def:b801] [use:6001] */          ADC(ram[0x0011]);
/* 024 [def:0001] [use:0001] */          //trace_PC(0x704D);
/* 025 [def:0001] [use:0001] */      case 0x704F: L_704f: //06 11 65
/* 026 [def:0101] [use:0001] */          ZN=ram[0x0011];
/* 027 [def:2001] [use:0100] */          C = ZN & 0x80; /* We're stealing ZN for use as a temp */
/* 028 [def:1801] [use:0100] */          ZN = ZN << 1;
/* 029 [def:0001] [use:1800] */          ram[0x0011] = ZN; /* Because at this point it actually has the correct value in it */
/* 030 [def:0001] [use:0001] */          //trace_PC(0x704F);
/* 031 [def:0001] [use:0001] */      case 0x7051: L_7051: //65 11 85
/* 032 [def:b801] [use:6001] */          ADC(ram[0x0011]);
/* 033 [def:0001] [use:0001] */          //trace_PC(0x7051);
/* 034 [def:0001] [use:0001] */      case 0x7053: L_7053: //85 CC A9
/* 035 [def:0001] [use:0008] */          ram[0x00CC] = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7053);
/* 037 [def:0001] [use:0001] */      case 0x7055: L_7055: //A9 14 85
/* 038 [def:0009] [use:0000] */          A=0x14;
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7055);
/* 041 [def:0001] [use:0001] */      case 0x7057: L_7057: //85 CB A2
/* 042 [def:0001] [use:0008] */          ram[0x00CB] = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x7057);
/* 044 [def:0001] [use:0001] */      case 0x7059: L_7059: //A2 1B E4
/* 045 [def:0001] [use:0001] */          X=0x1B;
/* 046 [def:1800] [use:0010] */  //      ZN = X;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x7059);
/* 048 [def:0001] [use:0001] */      case 0x705B: L_705b: //E4 10 F0
/* 049 [def:0101] [use:0001] */          ZN=ram[0x0010];
/* 050 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 051 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 052 [def:0001] [use:0001] */          //trace_PC(0x705B);
/* 053 [def:0001] [use:0001] */      case 0x705D: L_705d: //F0 1D B5
/* 054 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 055 [def:0001] [use:0001] */          {
/* 056 [def:0001] [use:0001] */              //trace_PC(0x705D);
/* 057 [def:0001] [use:0001] */              PC = 0x707c;
/*                           */              clockticks += 78;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x705D);
/* 002 [def:0001] [use:0001] */      case 0x705F: L_705f: //B5 41 95
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x41 + X)];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x705F);
/* 006 [def:0001] [use:0001] */      case 0x7061: L_7061: //95 44 B5
/* 007 [def:0001] [use:0019] */          ram[(unsigned char)(0x44 + X)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7061);
/* 009 [def:0001] [use:0001] */      case 0x7063: L_7063: //B5 42 95
/* 010 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x42 + X)];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7063);
/* 013 [def:0001] [use:0001] */      case 0x7065: L_7065: //95 45 B5
/* 014 [def:0001] [use:0019] */          ram[(unsigned char)(0x45 + X)] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7065);
/* 016 [def:0001] [use:0001] */      case 0x7067: L_7067: //B5 43 95
/* 017 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x43 + X)];
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7067);
/* 020 [def:0001] [use:0001] */      case 0x7069: L_7069: //95 46 B5
/* 021 [def:0001] [use:0019] */          ram[(unsigned char)(0x46 + X)] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7069);
/* 023 [def:0001] [use:0001] */      case 0x706B: L_706b: //B5 20 95
/* 024 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x20 + X)];
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x706B);
/* 027 [def:0001] [use:0001] */      case 0x706D: L_706d: //95 23 B5
/* 028 [def:0001] [use:0019] */          ram[(unsigned char)(0x23 + X)] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x706D);
/* 030 [def:0001] [use:0001] */      case 0x706F: L_706f: //B5 21 95
/* 031 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x21 + X)];
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x706F);
/* 034 [def:0001] [use:0001] */      case 0x7071: L_7071: //95 24 B5
/* 035 [def:0001] [use:0019] */          ram[(unsigned char)(0x24 + X)] = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7071);
/* 037 [def:0001] [use:0001] */      case 0x7073: L_7073: //B5 22 95
/* 038 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x22 + X)];
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7073);
/* 041 [def:0001] [use:0001] */      case 0x7075: L_7075: //95 25 CA
/* 042 [def:0001] [use:0019] */          ram[(unsigned char)(0x25 + X)] = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x7075);
/* 044 [def:0001] [use:0001] */      case 0x7077: L_7077: //CA CA CA
/* 045 [def:0011] [use:0010] */          X--;
/* 046 [def:1800] [use:0010] */  //      ZN = X;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x7077);
/* 048 [def:0001] [use:0001] */      case 0x7078: L_7078: //CA CA D0
/* 049 [def:0011] [use:0010] */          X--;
/* 050 [def:1800] [use:0010] */  //      ZN = X;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x7078);
/* 052 [def:0001] [use:0001] */      case 0x7079: L_7079: //CA D0 DF
/* 053 [def:0011] [use:0010] */          X--;
/* 054 [def:1801] [use:0010] */          ZN = X;
/* 055 [def:0001] [use:0001] */          //trace_PC(0x7079);
/* 056 [def:0001] [use:0001] */      case 0x707A: L_707a: //D0 DF A9
/* 057 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 058 [def:0001] [use:0001] */          {
/* 059 [def:0001] [use:0001] */              //trace_PC(0x707A);
/* 060 [def:0001] [use:0001] */              PC = 0x705b;
/*                           */              clockticks += 134;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x707A);
/* 002 [def:0001] [use:0001] */      case 0x707C: L_707c: //A9 0B 95
/* 003 [def:0009] [use:0000] */          A=0x0B;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x707C);
/* 006 [def:0001] [use:0001] */      case 0x707E: L_707e: //95 44 A9
/* 007 [def:0001] [use:0019] */          ram[(unsigned char)(0x44 + X)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x707E);
/* 009 [def:0001] [use:0001] */      case 0x7080: L_7080: //A9 00 95
/* 010 [def:0009] [use:0000] */          A=0x00;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7080);
/* 013 [def:0001] [use:0001] */      case 0x7082: L_7082: //95 45 95
/* 014 [def:0001] [use:0019] */          ram[(unsigned char)(0x45 + X)] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7082);
/* 016 [def:0001] [use:0001] */      case 0x7084: L_7084: //95 46 A9
/* 017 [def:0001] [use:0019] */          ram[(unsigned char)(0x46 + X)] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7084);
/* 019 [def:0001] [use:0001] */      case 0x7086: L_7086: //A9 F0 85
/* 020 [def:0009] [use:0000] */          A=0xF0;
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7086);
/* 023 [def:0001] [use:0001] */      case 0x7088: L_7088: //85 77 A6
/* 024 [def:0001] [use:0008] */          ram[0x0077] = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7088);
/* 026 [def:0001] [use:0001] */      case 0x708A: L_708a: //A6 0C B5
/* 027 [def:0001] [use:0001] */          X=ram[0x000C];
/* 028 [def:1800] [use:0010] */  //      ZN = X;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x708A);
/* 030 [def:0001] [use:0001] */      case 0x708C: L_708c: //B5 64 99
/* 031 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x64 + X)];
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x708C);
/* 034 [def:0001] [use:0001] */      case 0x708E: L_708e: //99 25 00
/* 035 [def:0001] [use:0021] */          ram[(unsigned short)(0x0025 + Y)] = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x708E);
/* 037 [def:0001] [use:0001] */      case 0x7091: L_7091: //B5 63 99
/* 038 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x63 + X)];
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7091);
/* 041 [def:0001] [use:0001] */      case 0x7093: L_7093: //99 24 00
/* 042 [def:0001] [use:0021] */          ram[(unsigned short)(0x0024 + Y)] = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x7093);
/* 044 [def:0001] [use:0001] */      case 0x7096: L_7096: //B5 62 99
/* 045 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x62 + X)];
/* 046 [def:1801] [use:0008] */          ZN = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x7096);
/* 048 [def:0001] [use:0001] */      case 0x7098: L_7098: //99 23 00
/* 049 [def:0001] [use:0021] */          ram[(unsigned short)(0x0023 + Y)] = A;
/* 050 [def:0001] [use:0001] */          //trace_PC(0x7098);
/* 051 [def:0001] [use:0001] */      case 0x709B: L_709b: //4C FF 6F
/* 052 [def:0001] [use:0001] */          //trace_PC(0x709B);
/* 053 [def:0001] [use:0001] */          PC = 0x6fff;
/*                           */          clockticks += 189; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x709E: L_709e: //98 10 09
/* 001 [def:0001] [use:0001] */          A=Y;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x709E);
/* 004 [def:0001] [use:0001] */      case 0x709F: L_709f: //10 09 20
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x709F);
/* 008 [def:0001] [use:0001] */              PC = 0x70aa;
/*                           */              clockticks += 5;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x709F);
/* 002 [def:0001] [use:0001] */      case 0x70A1: L_70a1: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xA3;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70A1);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 10; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70A4: L_70a4: //20 AA 70
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xA6;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70A4);
/* 004 [def:0001] [use:0001] */          PC = 0x70aa;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70A7: L_70a7: //4C B6 70
/* 001 [def:0001] [use:0001] */          //trace_PC(0x70A7);
/* 002 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70AA: L_70aa: //A8 8A 10
/* 001 [def:0021] [use:0008] */          Y=A;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70AA);
/* 004 [def:0001] [use:0001] */      case 0x70AB: L_70ab: //8A 10 0E
/* 005 [def:0001] [use:0001] */          A=X;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x70AB);
/* 008 [def:0001] [use:0001] */      case 0x70AC: L_70ac: //10 0E 20
/* 009 [def:0001] [use:1001] */          if (ZN < 0)
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x70AC);
/* 012 [def:0001] [use:0001] */              PC = 0x70bc;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x70AC);
/* 002 [def:0001] [use:0001] */      case 0x70AE: L_70ae: //20 B6 70
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xB0;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70AE);
/* 006 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70B1: L_70b1: //20 BC 70
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xB3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70B1);
/* 004 [def:0001] [use:0001] */          PC = 0x70bc;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70B4: L_70b4: //49 80 49
/* 001 [def:0009] [use:0008] */          A ^= 0x80;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70B4);
/* 004 [def:0001] [use:0001] */      case 0x70B6: L_70b6: //49 FF 18
/* 005 [def:0009] [use:0008] */          A ^= 0xFF;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x70B6);
/* 008 [def:0001] [use:0001] */      case 0x70B8: L_70b8: //18 69 01
/* 009 [def:2001] [use:0000] */          C = 0;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x70B8);
/* 011 [def:0001] [use:0001] */      case 0x70B9: L_70b9: //69 01 60
/* 012 [def:b801] [use:6001] */          ADC(0x01);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x70B9);
/* 014 [def:0001] [use:0001] */      case 0x70BB: L_70bb: //60 85 0D
/* 015 [def:0001] [use:0001] */          //trace_PC(0x70BB);
/* 016 [def:0001] [use:0001] */          PC=stack[++S];
/* 017 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 018 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 17; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70BC: L_70bc: //85 0D 98
/* 001 [def:0001] [use:0008] */          ram[0x000D] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x70BC);
/* 003 [def:0001] [use:0001] */      case 0x70BE: L_70be: //98 C5 0D
/* 004 [def:0001] [use:0001] */          A=Y;
/* 005 [def:1801] [use:0008] */          ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x70BE);
/* 007 [def:0001] [use:0001] */      case 0x70BF: L_70bf: //C5 0D 90
/* 008 [def:0001] [use:0001] */          ZN=ram[0x000D];
/* 009 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 010 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x70BF);
/* 012 [def:0001] [use:0001] */      case 0x70C1: L_70c1: //90 0E A4
/* 013 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x70C1);
/* 016 [def:0001] [use:0001] */              PC = 0x70d1;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x70C1);
/* 002 [def:0001] [use:0001] */      case 0x70C3: L_70c3: //A4 0D 85
/* 003 [def:0021] [use:0001] */          Y=ram[0x000D];
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70C3);
/* 006 [def:0001] [use:0001] */      case 0x70C5: L_70c5: //85 0D 98
/* 007 [def:0001] [use:0008] */          ram[0x000D] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x70C5);
/* 009 [def:0001] [use:0001] */      case 0x70C7: L_70c7: //98 20 D1
/* 010 [def:0001] [use:0001] */          A=Y;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x70C7);
/* 013 [def:0001] [use:0001] */      case 0x70C8: L_70c8: //20 D1 70
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0xCA;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x70C8);
/* 017 [def:0001] [use:0001] */          PC = 0x70d1;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70CB: L_70cb: //38 E9 40
/* 001 [def:2001] [use:0000] */          C = 1;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x70CB);
/* 003 [def:0001] [use:0001] */      case 0x70CC: L_70cc: //E9 40 4C
/* 004 [def:b809] [use:6009] */          SBC(0x40);
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70CC);
/* 006 [def:0001] [use:0001] */      case 0x70CE: L_70ce: //4C B6 70
/* 007 [def:0001] [use:0001] */          //trace_PC(0x70CE);
/* 008 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 8; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70D1: L_70d1: //20 EB 70
/* 001 [def:0001] [use:0001] */          stack[S--] = 0x70;
/* 002 [def:0001] [use:0001] */          stack[S--] = 0xD3;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70D1);
/* 004 [def:0001] [use:0001] */          PC = 0x70eb;
/*                           */          clockticks += 6; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70D4: L_70d4: //AA BD D9
/* 001 [def:0011] [use:0008] */          X=A;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70D4);
/* 004 [def:0001] [use:0001] */      case 0x70D5: L_70d5: //BD D9 70
/* 005 [def:0009] [use:0011] */          A=ram[0x70D9 + X /* can't wrap */];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x70D5);
/* 008 [def:0001] [use:0001] */      case 0x70D8: L_70d8: //60 00 02
/* 009 [def:0001] [use:0001] */          //trace_PC(0x70D8);
/* 010 [def:0001] [use:0001] */          PC=stack[++S];
/* 011 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 012 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70EB: L_70eb: //A0 04 C5
/* 001 [def:0021] [use:0000] */          Y=0x04;
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x70EB);
/* 004 [def:0001] [use:0001] */      case 0x70ED: L_70ed: //C5 0D 90
/* 005 [def:0001] [use:0001] */          ZN=ram[0x000D];
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x70ED);
/* 009 [def:0001] [use:0001] */      case 0x70EF: L_70ef: //90 02 E5
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x70EF);
/* 013 [def:0001] [use:0001] */              PC = 0x70f3;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x70EF);
/* 002 [def:0001] [use:0001] */      case 0x70F1: L_70f1: //E5 0D 26
/* 003 [def:b809] [use:6009] */          SBC(ram[0x000D]);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x70F1);
/* 005 [def:0001] [use:0001] */      case 0x70F3: L_70f3: //26 0C 0A
/* 006 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 007 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 008 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 009 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 010 [def:1801] [use:10100] */          ZN |= saveflags;
/* 011 [def:0001] [use:1800] */          ram[0x000C] = ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x70F3);
/* 013 [def:0001] [use:0001] */      case 0x70F5: L_70f5: //0A 88 10
/* 014 [def:2001] [use:0008] */          C = A & 0x80;
/* 015 [def:0009] [use:0008] */          A = A << 1;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x70F5);
/* 018 [def:0001] [use:0001] */      case 0x70F6: L_70f6: //88 10 F4
/* 019 [def:0021] [use:0020] */          Y--;
/* 020 [def:1801] [use:0020] */          ZN = Y;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x70F6);
/* 022 [def:0001] [use:0001] */      case 0x70F7: L_70f7: //10 F4 A5
/* 023 [def:0001] [use:1001] */          if (ZN < 0)
/* 024 [def:0001] [use:0001] */          {
/* 025 [def:0001] [use:0001] */              //trace_PC(0x70F7);
/* 026 [def:0001] [use:0001] */              PC = 0x70ed;
/*                           */              clockticks += 23;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x70F7);
/* 002 [def:0001] [use:0001] */      case 0x70F9: L_70f9: //A5 0C 29
/* 003 [def:0009] [use:0001] */          A=ram[0x000C];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70F9);
/* 006 [def:0001] [use:0001] */      case 0x70FB: L_70fb: //29 1F 60
/* 007 [def:0009] [use:0008] */          A &= 0x1F;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x70FB);
/* 010 [def:0001] [use:0001] */      case 0x70FD: L_70fd: //60 18 69
/* 011 [def:0001] [use:0001] */          //trace_PC(0x70FD);
/* 012 [def:0001] [use:0001] */          PC=stack[++S];
/* 013 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 014 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 34; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x70FE: L_70fe: //18 69 40
/* 001 [def:2001] [use:0000] */          C = 0;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x70FE);
/* 003 [def:0001] [use:0001] */      case 0x70FF: L_70ff: //69 40 10
/* 004 [def:b801] [use:6001] */          ADC(0x40);
/* 005 [def:0001] [use:0001] */          //trace_PC(0x70FF);
/* 006 [def:0001] [use:0001] */      case 0x7101: L_7101: //10 08 29
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7101);
/* 010 [def:0001] [use:0001] */              PC = 0x710b;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7101);
/* 002 [def:0001] [use:0001] */      case 0x7103: L_7103: //29 7F 20
/* 003 [def:0009] [use:0008] */          A &= 0x7F;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7103);
/* 006 [def:0001] [use:0001] */      case 0x7105: L_7105: //20 0B 71
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x07;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7105);
/* 010 [def:0001] [use:0001] */          PC = 0x710b;
/*                           */          clockticks += 16; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7108: L_7108: //4C B6 70
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7108);
/* 002 [def:0001] [use:0001] */          PC = 0x70b6;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x710B: L_710b: //C9 41 90
/* 001 [def:0101] [use:0000] */          ZN=0x41;
/* 002 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 003 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x710B);
/* 005 [def:0001] [use:0001] */      case 0x710D: L_710d: //90 04 49
/* 006 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x710D);
/* 009 [def:0001] [use:0001] */              PC = 0x7113;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x710D);
/* 002 [def:0001] [use:0001] */      case 0x710F: L_710f: //49 7F 69
/* 003 [def:0009] [use:0008] */          A ^= 0x7F;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x710F);
/* 006 [def:0001] [use:0001] */      case 0x7111: L_7111: //69 00 AA
/* 007 [def:b801] [use:6001] */          ADC(0x00);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7111);
/* 009 [def:0001] [use:0001] */      case 0x7113: L_7113: //AA BD 61
/* 010 [def:0011] [use:0008] */          X=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7113);
/* 013 [def:0001] [use:0001] */      case 0x7114: L_7114: //BD 61 4B
/* 014 [def:0009] [use:0011] */          A=ram[0x4B61 + X /* can't wrap */];
/* 015 [def:1801] [use:0008] */          ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7114);
/* 017 [def:0001] [use:0001] */      case 0x7117: L_7117: //60 A9 04
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7117);
/* 019 [def:0001] [use:0001] */          PC=stack[++S];
/* 020 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 021 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 23; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7118: L_7118: //A9 04 85
/* 001 [def:0009] [use:0000] */          A=0x04;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7118);
/* 004 [def:0001] [use:0001] */      case 0x711A: L_711a: //85 76 20
/* 005 [def:0001] [use:0008] */          ram[0x0076] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x711A);
/* 007 [def:0001] [use:0001] */      case 0x711C: L_711c: //20 A2 4B
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x1E;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x711C);
/* 011 [def:0001] [use:0001] */          PC = 0x4ba2;
/*                           */          clockticks += 11; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x711F: L_711f: //C6 76 D0
/* 001 [def:0001] [use:0001] */          ZN=ram[0x0076]-1;
/* 002 [def:0001] [use:0001] */          ram[0x0076] = ZN;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x711F);
/* 004 [def:0001] [use:0001] */      case 0x7121: L_7121: //D0 F9 A2
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7121);
/* 008 [def:0001] [use:0001] */              PC = 0x711c;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7121);
/* 002 [def:0001] [use:0001] */      case 0x7123: L_7123: //A2 C9 A9
/* 003 [def:0001] [use:0001] */          X=0xC9;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7123);
/* 006 [def:0001] [use:0001] */      case 0x7125: L_7125: //A9 47 85
/* 007 [def:0009] [use:0000] */          A=0x47;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7125);
/* 010 [def:0001] [use:0001] */      case 0x7127: L_7127: //85 04 A9
/* 011 [def:0001] [use:0008] */          ram[0x0004] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7127);
/* 013 [def:0001] [use:0001] */      case 0x7129: L_7129: //A9 02 85
/* 014 [def:0009] [use:0000] */          A=0x02;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7129);
/* 017 [def:0001] [use:0001] */      case 0x712B: L_712b: //85 03 A9
/* 018 [def:0001] [use:0008] */          ram[0x0003] = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x712B);
/* 020 [def:0001] [use:0001] */      case 0x712D: L_712d: //A9 C1 20
/* 021 [def:0009] [use:0000] */          A=0xC1;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x712D);
/* 024 [def:0001] [use:0001] */      case 0x712F: L_712f: //20 D5 7C
/* 025 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 026 [def:0001] [use:0001] */          stack[S--] = 0x31;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x712F);
/* 028 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 29; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7132: L_7132: //A9 BE 85
/* 001 [def:0009] [use:0000] */          A=0xBE;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7132);
/* 004 [def:0001] [use:0001] */      case 0x7134: L_7134: //85 09 A9
/* 005 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7134);
/* 007 [def:0001] [use:0001] */      case 0x7136: L_7136: //A9 75 85
/* 008 [def:0009] [use:0000] */          A=0x75;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7136);
/* 011 [def:0001] [use:0001] */      case 0x7138: L_7138: //85 0A A9
/* 012 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7138);
/* 014 [def:0001] [use:0001] */      case 0x713A: L_713a: //A9 00 85
/* 015 [def:0009] [use:0000] */          A=0x00;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x713A);
/* 018 [def:0001] [use:0001] */      case 0x713C: L_713c: //85 01 A9
/* 019 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x713C);
/* 021 [def:0001] [use:0001] */      case 0x713E: L_713e: //A9 70 A2
/* 022 [def:0009] [use:0000] */          A=0x70;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x713E);
/* 025 [def:0001] [use:0001] */      case 0x7140: L_7140: //A2 20 20
/* 026 [def:0001] [use:0001] */          X=0x20;
/* 027 [def:1801] [use:0010] */          ZN = X;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x7140);
/* 029 [def:0001] [use:0001] */      case 0x7142: L_7142: //20 7F 71
/* 030 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 031 [def:0001] [use:0001] */          stack[S--] = 0x44;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7142);
/* 033 [def:0001] [use:0001] */          PC = 0x717f;
/*                           */          clockticks += 27; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7145: L_7145: //4C D6 79
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7145);
/* 002 [def:0001] [use:0001] */          PC = 0x79d6;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7148: L_7148: //A9 C5 A2
/* 001 [def:0009] [use:0000] */          A=0xC5;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7148);
/* 004 [def:0001] [use:0001] */      case 0x714A: L_714a: //A2 C9 20
/* 005 [def:0001] [use:0001] */          X=0xC9;
/* 006 [def:1801] [use:0010] */          ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x714A);
/* 008 [def:0001] [use:0001] */      case 0x714C: L_714c: //20 D5 7C
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x4E;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x714C);
/* 012 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x714F: L_714f: //A2 BE A9
/* 001 [def:0001] [use:0001] */          X=0xBE;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x714F);
/* 004 [def:0001] [use:0001] */      case 0x7151: L_7151: //A9 75 85
/* 005 [def:0009] [use:0000] */          A=0x75;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7151);
/* 008 [def:0001] [use:0001] */      case 0x7153: L_7153: //85 0A 86
/* 009 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7153);
/* 011 [def:0001] [use:0001] */      case 0x7155: L_7155: //86 09 D0
/* 012 [def:0001] [use:0001] */          ram[0x0009] = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7155);
/* 014 [def:0001] [use:0001] */      case 0x7157: L_7157: //D0 2E AD
/* 015 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7157);
/* 018 [def:0001] [use:0001] */              PC = 0x7187;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7157);
/* 002 [def:0001] [use:0001] */      case 0x7159: L_7159: //AD 03 28
/* 003 [def:0009] [use:0001] */          A=ram[0x2803];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7159);
/* 006 [def:0001] [use:0001] */      case 0x715C: L_715c: //29 03 A2
/* 007 [def:0009] [use:0008] */          A &= 0x03;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x715C);
/* 010 [def:0001] [use:0001] */      case 0x715E: L_715e: //A2 10 86
/* 011 [def:0001] [use:0001] */          X=0x10;
/* 012 [def:1800] [use:0010] */  //      ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x715E);
/* 014 [def:0001] [use:0001] */      case 0x7160: L_7160: //86 01 0A
/* 015 [def:0001] [use:0001] */          ram[0x0001] = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7160);
/* 017 [def:0001] [use:0001] */      case 0x7162: L_7162: //0A AA BD
/* 018 [def:2001] [use:0008] */          C = A & 0x80;
/* 019 [def:0009] [use:0008] */          A = A << 1;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7162);
/* 022 [def:0001] [use:0001] */      case 0x7163: L_7163: //AA BD F1
/* 023 [def:0011] [use:0008] */          X=A;
/* 024 [def:1800] [use:0008] */  //      ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7163);
/* 026 [def:0001] [use:0001] */      case 0x7164: L_7164: //BD F1 71
/* 027 [def:0009] [use:0011] */          A=ram[0x71F1 + X /* can't wrap */];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7164);
/* 030 [def:0001] [use:0001] */      case 0x7167: L_7167: //85 0A BD
/* 031 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7167);
/* 033 [def:0001] [use:0001] */      case 0x7169: L_7169: //BD F0 71
/* 034 [def:0009] [use:0011] */          A=ram[0x71F0 + X /* can't wrap */];
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7169);
/* 037 [def:0001] [use:0001] */      case 0x716C: L_716c: //85 09 71
/* 038 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x716C);
/* 040 [def:0001] [use:0001] */      case 0x716E: L_716e: //71 09 85
/* 041 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0009 + 1)];
/* 042 [def:0001] [use:0001] */          temp<<=8;
/* 043 [def:0001] [use:0001] */          temp|=ram[0x0009];
/* 044 [def:0001] [use:0001] */          temp+=Y;
/* 045 [def:b801] [use:6001] */          ADC(ram[temp]);
/* 046 [def:0001] [use:0001] */          //trace_PC(0x716E);
/* 047 [def:0001] [use:0001] */      case 0x7170: L_7170: //85 09 90
/* 048 [def:0001] [use:0008] */          ram[0x0009] = A;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x7170);
/* 050 [def:0001] [use:0001] */      case 0x7172: L_7172: //90 02 E6
/* 051 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 052 [def:0001] [use:0001] */          {
/* 053 [def:0001] [use:0001] */              //trace_PC(0x7172);
/* 054 [def:0001] [use:0001] */              PC = 0x7176;
/*                           */              clockticks += 50;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7172);
/* 002 [def:0001] [use:0001] */      case 0x7174: L_7174: //E6 0A 98
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x000A];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7174);
/* 005 [def:0001] [use:0001] */      case 0x7176: L_7176: //98 0A A8
/* 006 [def:0001] [use:0001] */          A=Y;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7176);
/* 009 [def:0001] [use:0001] */      case 0x7177: L_7177: //0A A8 B9
/* 010 [def:2001] [use:0008] */          C = A & 0x80;
/* 011 [def:0009] [use:0008] */          A = A << 1;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7177);
/* 014 [def:0001] [use:0001] */      case 0x7178: L_7178: //A8 B9 D4
/* 015 [def:0021] [use:0008] */          Y=A;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7178);
/* 018 [def:0001] [use:0001] */      case 0x7179: L_7179: //B9 D4 71
/* 019 [def:0009] [use:0021] */          A=ram[0x71D4 + Y /* can't wrap */];
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7179);
/* 022 [def:0001] [use:0001] */      case 0x717C: L_717c: //BE D5 71
/* 023 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x71D5 + Y)];
/* 024 [def:1801] [use:0010] */          ZN = X;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x717C);
/* 026 [def:0001] [use:0001] */      case 0x717F: L_717f: //20 1F 7A
/* 027 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 028 [def:0001] [use:0001] */          stack[S--] = 0x81;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x717F);
/* 030 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 74; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7182: L_7182: //A9 70 20
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7182);
/* 004 [def:0001] [use:0001] */      case 0x7184: L_7184: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x86;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7184);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7187: L_7187: //A0 00 A2
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7187);
/* 004 [def:0001] [use:0001] */      case 0x7189: L_7189: //A2 00 A1
/* 005 [def:0001] [use:0001] */          X=0x00;
/* 006 [def:1800] [use:0010] */  //      ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7189);
/* 008 [def:0001] [use:0001] */      case 0x718B: L_718b: //A1 09 85
/* 009 [def:0001] [use:0001] */          temp+=X;
/* 010 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0009 + 1)];
/* 011 [def:0001] [use:0001] */          temp<<=8;
/* 012 [def:0001] [use:0001] */          temp|=ram[0x0009];
/* 013 [def:0001] [use:0001] */          A=ram[temp];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x718B);
/* 016 [def:0001] [use:0001] */      case 0x718D: L_718d: //85 0C 4A
/* 017 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x718D);
/* 019 [def:0001] [use:0001] */      case 0x718F: L_718f: //4A 4A 20
/* 020 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 021 [def:0009] [use:0008] */          A = A >> 1;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x718F);
/* 024 [def:0001] [use:0001] */      case 0x7190: L_7190: //4A 20 B0
/* 025 [def:2001] [use:0008] */          C = A & 0x01;
/* 026 [def:0009] [use:0008] */          A = A >> 1;
/* 027 [def:1801] [use:0008] */          ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x7190);
/* 029 [def:0001] [use:0001] */      case 0x7191: L_7191: //20 B0 71
/* 030 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 031 [def:0001] [use:0001] */          stack[S--] = 0x93;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7191);
/* 033 [def:0001] [use:0001] */          PC = 0x71b0;
/*                           */          clockticks += 24; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7194: L_7194: //A1 09 2A
/* 001 [def:0001] [use:0001] */          temp+=X;
/* 002 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0009 + 1)];
/* 003 [def:0001] [use:0001] */          temp<<=8;
/* 004 [def:0001] [use:0001] */          temp|=ram[0x0009];
/* 005 [def:0001] [use:0001] */          A=ram[temp];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7194);
/* 008 [def:0001] [use:0001] */      case 0x7196: L_7196: //2A 26 0C
/* 009 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 010 [def:2001] [use:0008] */          C = A & 0x80;
/* 011 [def:0009] [use:0008] */          A = A << 1;
/* 012 [def:0009] [use:10008] */          A |= saveflags;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7196);
/* 015 [def:0001] [use:0001] */      case 0x7197: L_7197: //26 0C 2A
/* 016 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 017 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 018 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 019 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 020 [def:1801] [use:10100] */          ZN |= saveflags;
/* 021 [def:0001] [use:1800] */          ram[0x000C] = ZN;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7197);
/* 023 [def:0001] [use:0001] */      case 0x7199: L_7199: //2A A5 0C
/* 024 [def:10000] [use:2000] */  //      saveflags=(C != 0 ? 1 : 0);
/* 025 [def:2001] [use:0008] */          C = A & 0x80;
/* 026 [def:0008] [use:0008] */  //      A = A << 1;
/* 027 [def:0008] [use:10008] */  //      A |= saveflags;
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7199);
/* 030 [def:0001] [use:0001] */      case 0x719A: L_719a: //A5 0C 2A
/* 031 [def:0009] [use:0001] */          A=ram[0x000C];
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x719A);
/* 034 [def:0001] [use:0001] */      case 0x719C: L_719c: //2A 0A 20
/* 035 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 036 [def:2000] [use:0008] */  //      C = A & 0x80;
/* 037 [def:0009] [use:0008] */          A = A << 1;
/* 038 [def:0009] [use:10008] */          A |= saveflags;
/* 039 [def:1800] [use:0008] */  //      ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x719C);
/* 041 [def:0001] [use:0001] */      case 0x719D: L_719d: //0A 20 B6
/* 042 [def:2001] [use:0008] */          C = A & 0x80;
/* 043 [def:0009] [use:0008] */          A = A << 1;
/* 044 [def:1801] [use:0008] */          ZN = A;
/* 045 [def:0001] [use:0001] */          //trace_PC(0x719D);
/* 046 [def:0001] [use:0001] */      case 0x719E: L_719e: //20 B6 71
/* 047 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 048 [def:0001] [use:0001] */          stack[S--] = 0xA0;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x719E);
/* 050 [def:0001] [use:0001] */          PC = 0x71b6;
/*                           */          clockticks += 28; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x71A1: L_71a1: //A1 09 85
/* 001 [def:0001] [use:0001] */          temp+=X;
/* 002 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0009 + 1)];
/* 003 [def:0001] [use:0001] */          temp<<=8;
/* 004 [def:0001] [use:0001] */          temp|=ram[0x0009];
/* 005 [def:0001] [use:0001] */          A=ram[temp];
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x71A1);
/* 008 [def:0001] [use:0001] */      case 0x71A3: L_71a3: //85 0C 20
/* 009 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x71A3);
/* 011 [def:0001] [use:0001] */      case 0x71A5: L_71a5: //20 B0 71
/* 012 [def:0001] [use:0001] */          stack[S--] = 0x71;
/* 013 [def:0001] [use:0001] */          stack[S--] = 0xA7;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x71A5);
/* 015 [def:0001] [use:0001] */          PC = 0x71b0;
/*                           */          clockticks += 14; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x71A8: L_71a8: //46 0C 90
/* 001 [def:0101] [use:0001] */          ZN=ram[0x000C];
/* 002 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 003 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 004 [def:0001] [use:0100] */          ram[0x000C] = ZN;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x71A8);
/* 006 [def:0001] [use:0001] */      case 0x71AA: L_71aa: //90 DF 88
/* 007 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x71AA);
/* 010 [def:0001] [use:0001] */              PC = 0x718b;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x71AA);
/* 002 [def:0001] [use:0001] */      case 0x71AC: L_71ac: //88 4C 55
/* 003 [def:0021] [use:0020] */          Y--;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x71AC);
/* 006 [def:0001] [use:0001] */      case 0x71AD: L_71ad: //4C 55 7A
/* 007 [def:0001] [use:0001] */          //trace_PC(0x71AD);
/* 008 [def:0001] [use:0001] */          PC = 0x7a55;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x71B0: L_71b0: //E6 09 D0
/* 001 [def:1801] [use:0001] */          ZN=++ram[0x0009];
/* 002 [def:0001] [use:0001] */          //trace_PC(0x71B0);
/* 003 [def:0001] [use:0001] */      case 0x71B2: L_71b2: //D0 02 E6
/* 004 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 005 [def:0001] [use:0001] */          {
/* 006 [def:0001] [use:0001] */              //trace_PC(0x71B2);
/* 007 [def:0001] [use:0001] */              PC = 0x71b6;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x71B2);
/* 002 [def:0001] [use:0001] */      case 0x71B6: L_71b6: //29 3E D0
/* 003 [def:0009] [use:0008] */          A &= 0x3E;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x71B6);
/* 006 [def:0001] [use:0001] */      case 0x71B8: L_71b8: //D0 04 68
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x71B8);
/* 010 [def:0001] [use:0001] */              PC = 0x71be;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x71B8);
/* 002 [def:0001] [use:0001] */      case 0x71BA: L_71ba: //68 68 D0
/* 003 [def:0001] [use:0001] */          A=stack[++S];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x71BA);
/* 006 [def:0001] [use:0001] */      case 0x71BB: L_71bb: //68 D0 EE
/* 007 [def:0001] [use:0001] */          A=stack[++S];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x71BB);
/* 010 [def:0001] [use:0001] */      case 0x71BC: L_71bc: //D0 EE C9
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x71BC);
/* 014 [def:0001] [use:0001] */              PC = 0x71ac;
/*                           */              clockticks += 23;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x71BC);
/* 002 [def:0001] [use:0001] */      case 0x71BE: L_71be: //C9 0A 90
/* 003 [def:0101] [use:0000] */          ZN=0x0A;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x71BE);
/* 007 [def:0001] [use:0001] */      case 0x71C0: L_71c0: //90 02 69
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x71C0);
/* 011 [def:0001] [use:0001] */              PC = 0x71c4;
/*                           */              clockticks += 28;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x71C0);
/* 002 [def:0001] [use:0001] */      case 0x71C2: L_71c2: //69 0D AA
/* 003 [def:b801] [use:6001] */          ADC(0x0D);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x71C2);
/* 005 [def:0001] [use:0001] */      case 0x71C4: L_71c4: //AA BD F6
/* 006 [def:0011] [use:0008] */          X=A;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x71C4);
/* 009 [def:0001] [use:0001] */      case 0x71C5: L_71c5: //BD F6 56
/* 010 [def:0009] [use:0011] */          A=ram[0x56F6 + X /* can't wrap */];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x71C5);
/* 013 [def:0001] [use:0001] */      case 0x71C8: L_71c8: //91 03 C8
/* 014 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 015 [def:0001] [use:0001] */          //trace_PC(0x71C8);
/* 016 [def:0001] [use:0001] */      case 0x71CA: L_71ca: //C8 BD F7
/* 017 [def:0021] [use:0020] */          Y++;
/* 018 [def:1800] [use:0020] */  //      ZN = Y;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x71CA);
/* 020 [def:0001] [use:0001] */      case 0x71CB: L_71cb: //BD F7 56
/* 021 [def:0009] [use:0011] */          A=ram[0x56F7 + X /* can't wrap */];
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x71CB);
/* 024 [def:0001] [use:0001] */      case 0x71CE: L_71ce: //91 03 C8
/* 025 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 026 [def:0001] [use:0001] */          //trace_PC(0x71CE);
/* 027 [def:0001] [use:0001] */      case 0x71D0: L_71d0: //C8 A2 00
/* 028 [def:0021] [use:0020] */          Y++;
/* 029 [def:1800] [use:0020] */  //      ZN = Y;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x71D0);
/* 031 [def:0001] [use:0001] */      case 0x71D1: L_71d1: //A2 00 60
/* 032 [def:0001] [use:0001] */          X=0x00;
/* 033 [def:1801] [use:0010] */          ZN = X;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x71D1);
/* 035 [def:0001] [use:0001] */      case 0x71D3: L_71d3: //60 68 B6
/* 036 [def:0001] [use:0001] */          //trace_PC(0x71D3);
/* 037 [def:0001] [use:0001] */          PC=stack[++S];
/* 038 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 039 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 65; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x74E7: L_74e7: //24 73 10
/* 001 [def:1101] [use:0001] */          ZN=ram[0x0073];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x74E7);
/* 005 [def:0001] [use:0001] */      case 0x74E9: L_74e9: //10 29 8A
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x74E9);
/* 009 [def:0001] [use:0001] */              PC = 0x7514;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x74E9);
/* 002 [def:0001] [use:0001] */      case 0x74EB: L_74eb: //8A F0 07
/* 003 [def:0001] [use:0001] */          A=X;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x74EB);
/* 006 [def:0001] [use:0001] */      case 0x74EC: L_74ec: //F0 07 C0
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x74EC);
/* 010 [def:0001] [use:0001] */              PC = 0x74f5;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x74EC);
/* 002 [def:0001] [use:0001] */      case 0x74EE: L_74ee: //C0 19 D0
/* 003 [def:0101] [use:0001] */          ZN=0x19;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x74EE);
/* 007 [def:0001] [use:0001] */      case 0x74F0: L_74f0: //D0 22 69
/* 008 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x74F0);
/* 011 [def:0001] [use:0001] */              PC = 0x7514;
/*                           */              clockticks += 15;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x74F0);
/* 002 [def:0001] [use:0001] */      case 0x74F2: L_74f2: //69 18 A8
/* 003 [def:b801] [use:6001] */          ADC(0x18);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x74F2);
/* 005 [def:0001] [use:0001] */      case 0x74F4: L_74f4: //A8 B9 00
/* 006 [def:0021] [use:0008] */          Y=A;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x74F4);
/* 009 [def:0001] [use:0001] */      case 0x74F5: L_74f5: //B9 00 02
/* 010 [def:0009] [use:0021] */          A=ram[0x0200 + Y /* can't wrap */];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x74F5);
/* 013 [def:0001] [use:0001] */      case 0x74F8: L_74f8: //C0 1A F0
/* 014 [def:0101] [use:0001] */          ZN=0x1A;
/* 015 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 016 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x74F8);
/* 018 [def:0001] [use:0001] */      case 0x74FA: L_74fa: //F0 1A 90
/* 019 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 020 [def:0001] [use:0001] */          {
/* 021 [def:0001] [use:0001] */              //trace_PC(0x74FA);
/* 022 [def:0001] [use:0001] */              PC = 0x7516;
/*                           */              clockticks += 29;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x74FA);
/* 002 [def:0001] [use:0001] */      case 0x74FC: L_74fc: //90 2A A9
/* 003 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x74FC);
/* 006 [def:0001] [use:0001] */              PC = 0x7528;
/*                           */              clockticks += 31;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x74FC);
/* 002 [def:0001] [use:0001] */      case 0x74FE: L_74fe: //A9 00 99
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x74FE);
/* 006 [def:0001] [use:0001] */      case 0x7500: L_7500: //99 00 02
/* 007 [def:0001] [use:0021] */          ram[(unsigned short)(0x0200 + Y)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7500);
/* 009 [def:0001] [use:0001] */      case 0x7503: L_7503: //A2 E1 68
/* 010 [def:0001] [use:0001] */          X=0xE1;
/* 011 [def:1800] [use:0010] */  //      ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7503);
/* 013 [def:0001] [use:0001] */      case 0x7505: L_7505: //68 68 8A
/* 014 [def:0001] [use:0001] */          A=stack[++S];
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7505);
/* 017 [def:0001] [use:0001] */      case 0x7506: L_7506: //68 8A 6D
/* 018 [def:0001] [use:0001] */          A=stack[++S];
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7506);
/* 021 [def:0001] [use:0001] */      case 0x7507: L_7507: //8A 6D EF
/* 022 [def:0001] [use:0001] */          A=X;
/* 023 [def:1800] [use:0008] */  //      ZN = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7507);
/* 025 [def:0001] [use:0001] */      case 0x7508: L_7508: //6D EF 02
/* 026 [def:b801] [use:6001] */          ADC(ram[0x02EF]);
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7508);
/* 028 [def:0001] [use:0001] */      case 0x750B: L_750b: //B0 04 A9
/* 029 [def:0001] [use:2001] */          if (C)
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x750B);
/* 032 [def:0001] [use:0001] */              PC = 0x7511;
/*                           */              clockticks += 58;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x750B);
/* 002 [def:0001] [use:0001] */      case 0x750D: L_750d: //A9 00 85
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x750D);
/* 006 [def:0001] [use:0001] */      case 0x750F: L_750f: //85 73 8D
/* 007 [def:0001] [use:0008] */          ram[0x0073] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x750F);
/* 009 [def:0001] [use:0001] */      case 0x7511: L_7511: //8D EF 02
/* 010 [def:0001] [use:0008] */          ram[0x02EF] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7511);
/* 012 [def:0001] [use:0001] */      case 0x7514: L_7514: //18 60 A2
/* 013 [def:2001] [use:0000] */          C = 0;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7514);
/* 015 [def:0001] [use:0001] */      case 0x7515: L_7515: //60 A2 80
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7515);
/* 017 [def:0001] [use:0001] */          PC=stack[++S];
/* 018 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 019 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 74; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7516: L_7516: //A2 80 EC
/* 001 [def:0001] [use:0001] */          X=0x80;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7516);
/* 004 [def:0001] [use:0001] */      case 0x7528: L_7528: //A2 F8 38
/* 005 [def:0001] [use:0001] */          X=0xF8;
/* 006 [def:1801] [use:0010] */          ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7528);
/* 008 [def:0001] [use:0001] */      case 0x752A: L_752a: //38 66 71
/* 009 [def:2001] [use:0000] */          C = 1;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x752A);
/* 011 [def:0001] [use:0001] */      case 0x752B: L_752b: //66 71 C4
/* 012 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 013 [def:0101] [use:0001] */          ZN=ram[0x0071];
/* 014 [def:2000] [use:0100] */  //      C = ZN & 0x01;
/* 015 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 016 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 017 [def:0001] [use:0100] */          ram[0x0071] = ZN;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x752B);
/* 019 [def:0001] [use:0001] */      case 0x752D: L_752d: //C4 72 F0
/* 020 [def:0001] [use:0001] */          ZN=ram[0x0072];
/* 021 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff);
/* 022 [def:0001] [use:0001] */          ZN=/*+0x100*/Y-ZN;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x752D);
/* 024 [def:0001] [use:0001] */      case 0x752F: L_752f: //F0 D4 84
/* 025 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 026 [def:0001] [use:0001] */          {
/* 027 [def:0001] [use:0001] */              //trace_PC(0x752F);
/* 028 [def:0001] [use:0001] */              PC = 0x7505;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x752F);
/* 002 [def:0001] [use:0001] */      case 0x7531: L_7531: //84 72 0A
/* 003 [def:0001] [use:0020] */          ram[0x0072] = Y;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7531);
/* 005 [def:0001] [use:0001] */      case 0x7533: L_7533: //0A 29 86
/* 006 [def:2001] [use:0008] */          C = A & 0x80;
/* 007 [def:0009] [use:0008] */          A = A << 1;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7533);
/* 010 [def:0001] [use:0001] */      case 0x7534: L_7534: //29 86 85
/* 011 [def:0009] [use:0008] */          A &= 0x86;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7534);
/* 014 [def:0001] [use:0001] */      case 0x7536: L_7536: //85 10 30
/* 015 [def:0001] [use:0008] */          ram[0x0010] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7536);
/* 017 [def:0001] [use:0001] */      case 0x7538: L_7538: //30 1A F0
/* 018 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x7538);
/* 021 [def:0001] [use:0001] */              PC = 0x7554;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7538);
/* 002 [def:0001] [use:0001] */      case 0x753A: L_753a: //F0 18 B9
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x753A);
/* 006 [def:0001] [use:0001] */              PC = 0x7554;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x753A);
/* 002 [def:0001] [use:0001] */      case 0x7554: L_7554: //A2 00 20
/* 003 [def:0001] [use:0001] */          X=0x00;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7554);
/* 006 [def:0001] [use:0001] */      case 0x7556: L_7556: //20 67 75
/* 007 [def:0001] [use:0001] */          stack[S--] = 0x75;
/* 008 [def:0001] [use:0001] */          stack[S--] = 0x58;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7556);
/* 010 [def:0001] [use:0001] */          PC = 0x7567;
/*                           */          clockticks += 40; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7559: L_7559: //A2 21 98
/* 001 [def:0001] [use:0001] */          X=0x21;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7559);
/* 004 [def:0001] [use:0001] */      case 0x755B: L_755b: //98 18 69
/* 005 [def:0001] [use:0001] */          A=Y;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x755B);
/* 008 [def:0001] [use:0001] */      case 0x755C: L_755c: //18 69 21
/* 009 [def:2001] [use:0000] */          C = 0;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x755C);
/* 011 [def:0001] [use:0001] */      case 0x755D: L_755d: //69 21 A8
/* 012 [def:b801] [use:6001] */          ADC(0x21);
/* 013 [def:0001] [use:0001] */          //trace_PC(0x755D);
/* 014 [def:0001] [use:0001] */      case 0x755F: L_755f: //A8 20 67
/* 015 [def:0021] [use:0008] */          Y=A;
/* 016 [def:1801] [use:0008] */          ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x755F);
/* 018 [def:0001] [use:0001] */      case 0x7560: L_7560: //20 67 75
/* 019 [def:0001] [use:0001] */          stack[S--] = 0x75;
/* 020 [def:0001] [use:0001] */          stack[S--] = 0x62;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7560);
/* 022 [def:0001] [use:0001] */          PC = 0x7567;
/*                           */          clockticks += 18; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7563: L_7563: //A2 B0 D0
/* 001 [def:0001] [use:0001] */          X=0xB0;
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7563);
/* 004 [def:0001] [use:0001] */      case 0x7565: L_7565: //D0 9E 86
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7565);
/* 008 [def:0001] [use:0001] */              PC = 0x7505;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7565);
/* 002 [def:0001] [use:0001] */      case 0x7567: L_7567: //86 11 B9
/* 003 [def:0001] [use:0001] */          ram[0x0011] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7567);
/* 005 [def:0001] [use:0001] */      case 0x7569: L_7569: //B9 21 02
/* 006 [def:0009] [use:0021] */          A=ram[0x0221 + Y /* can't wrap */];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7569);
/* 009 [def:0001] [use:0001] */      case 0x756C: L_756c: //30 13 BD
/* 010 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x756C);
/* 013 [def:0001] [use:0001] */              PC = 0x7581;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x756C);
/* 002 [def:0001] [use:0001] */      case 0x756E: L_756e: //BD 3A 02
/* 003 [def:0009] [use:0011] */          A=ram[0x023A + X /* can't wrap */];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x756E);
/* 006 [def:0001] [use:0001] */      case 0x7571: L_7571: //30 18 20
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7571);
/* 010 [def:0001] [use:0001] */              PC = 0x758b;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7571);
/* 002 [def:0001] [use:0001] */      case 0x7578: L_7578: //A9 00 38
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7578);
/* 006 [def:0001] [use:0001] */      case 0x757A: L_757a: //38 F9 21
/* 007 [def:2001] [use:0000] */          C = 1;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x757A);
/* 009 [def:0001] [use:0001] */      case 0x757B: L_757b: //F9 21 02
/* 010 [def:b801] [use:6021] */          SBC(ram[(unsigned short)(0x0221 + Y)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x757B);
/* 012 [def:0001] [use:0001] */      case 0x757E: L_757e: //4C 9A 75
/* 013 [def:0001] [use:0001] */          //trace_PC(0x757E);
/* 014 [def:0001] [use:0001] */          PC = 0x759a;
/*                           */          clockticks += 31; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7581: L_7581: //BD 3A 02
/* 001 [def:0009] [use:0011] */          A=ram[0x023A + X /* can't wrap */];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7581);
/* 004 [def:0001] [use:0001] */      case 0x7584: L_7584: //10 05 20
/* 005 [def:0001] [use:1001] */          if (ZN < 0)
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7584);
/* 008 [def:0001] [use:0001] */              PC = 0x758b;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7584);
/* 002 [def:0001] [use:0001] */      case 0x7586: L_7586: //20 B1 75
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x75;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0x88;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7586);
/* 006 [def:0001] [use:0001] */          PC = 0x75b1;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7589: L_7589: //90 ED B9
/* 001 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x7589);
/* 004 [def:0001] [use:0001] */              PC = 0x7578;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7589);
/* 002 [def:0001] [use:0001] */      case 0x758B: L_758b: //B9 21 02
/* 003 [def:0009] [use:0021] */          A=ram[0x0221 + Y /* can't wrap */];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x758B);
/* 006 [def:0001] [use:0001] */      case 0x758E: L_758e: //24 10 10
/* 007 [def:1101] [use:0001] */          ZN=ram[0x0010];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 008 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 009 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 010 [def:0001] [use:0001] */          //trace_PC(0x758E);
/* 011 [def:0001] [use:0001] */      case 0x7590: L_7590: //10 07 C9
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7590);
/* 015 [def:0001] [use:0001] */              PC = 0x7599;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7590);
/* 002 [def:0001] [use:0001] */      case 0x7599: L_7599: //2A 20 EA
/* 003 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 004 [def:2001] [use:0008] */          C = A & 0x80;
/* 005 [def:0009] [use:0008] */          A = A << 1;
/* 006 [def:0009] [use:10008] */          A |= saveflags;
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7599);
/* 009 [def:0001] [use:0001] */      case 0x759A: L_759a: //20 EA 68
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x75;
/* 011 [def:0001] [use:0001] */          stack[S--] = 0x9C;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x759A);
/* 013 [def:0001] [use:0001] */          PC = 0x68ea;
/*                           */          clockticks += 19; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x759D: L_759d: //10 06 C9
/* 001 [def:0001] [use:1001] */          if (ZN < 0)
/* 002 [def:0001] [use:0001] */          {
/* 003 [def:0001] [use:0001] */              //trace_PC(0x759D);
/* 004 [def:0001] [use:0001] */              PC = 0x75a5;
/*                           */              clockticks += 3;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x759D);
/* 002 [def:0001] [use:0001] */      case 0x759F: L_759f: //C9 FB 90
/* 003 [def:0101] [use:0000] */          ZN=0xFB;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x759F);
/* 007 [def:0001] [use:0001] */      case 0x75A1: L_75a1: //90 08 A9
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x75A1);
/* 011 [def:0001] [use:0001] */              PC = 0x75ab;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x75A1);
/* 002 [def:0001] [use:0001] */      case 0x75A5: L_75a5: //C9 06 B0
/* 003 [def:0101] [use:0000] */          ZN=0x06;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x75A5);
/* 007 [def:0001] [use:0001] */      case 0x75A7: L_75a7: //B0 02 A9
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x75A7);
/* 011 [def:0001] [use:0001] */              PC = 0x75ab;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x75A7);
/* 002 [def:0001] [use:0001] */      case 0x75AB: L_75ab: //A6 11 9D
/* 003 [def:0001] [use:0001] */          X=ram[0x0011];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x75AB);
/* 006 [def:0001] [use:0001] */      case 0x75AD: L_75ad: //9D 3A 02
/* 007 [def:0001] [use:0019] */          ram[0x023A + X /* can't wrap */] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x75AD);
/* 009 [def:0001] [use:0001] */      case 0x75B0: L_75b0: //60 B9 A5
/* 010 [def:0001] [use:0001] */          //trace_PC(0x75B0);
/* 011 [def:0001] [use:0001] */          PC=stack[++S];
/* 012 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 013 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 26; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x75B1: L_75b1: //B9 A5 02
/* 001 [def:0009] [use:0021] */          A=ram[0x02A5 + Y /* can't wrap */];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x75B1);
/* 004 [def:0001] [use:0001] */      case 0x75B4: L_75b4: //DD BE 02
/* 005 [def:0101] [use:0011] */          ZN=ram[(unsigned short)(0x02BE + X)];
/* 006 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 007 [def:1800] [use:0108] */  //      ZN=A/*+0x100*/-ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x75B4);
/* 009 [def:0001] [use:0001] */      case 0x75B7: L_75b7: //B9 63 02
/* 010 [def:0009] [use:0021] */          A=ram[0x0263 + Y /* can't wrap */];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x75B7);
/* 013 [def:0001] [use:0001] */      case 0x75BA: L_75ba: //FD 7C 02
/* 014 [def:b809] [use:6019] */          SBC(ram[(unsigned short)(0x027C + X)]);
/* 015 [def:0001] [use:0001] */          //trace_PC(0x75BA);
/* 016 [def:0001] [use:0001] */      case 0x75BD: L_75bd: //60 1F C4
/* 017 [def:0001] [use:0001] */          //trace_PC(0x75BD);
/* 018 [def:0001] [use:0001] */          PC=stack[++S];
/* 019 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 020 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x770D: L_770d: //2C 41 77
/* 001 [def:1101] [use:0001] */          ZN=ram[0x7741];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x770D);
/* 005 [def:0001] [use:0001] */      case 0x7710: L_7710: //18 90 09
/* 006 [def:2001] [use:0000] */          C = 0;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7710);
/* 008 [def:0001] [use:0001] */      case 0x7711: L_7711: //90 09 38
/* 009 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x7711);
/* 012 [def:0001] [use:0001] */              PC = 0x771c;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7711);
/* 002 [def:0001] [use:0001] */      case 0x7713: L_7713: //38 B0 01
/* 003 [def:2001] [use:0000] */          C = 1;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7713);
/* 005 [def:0001] [use:0001] */      case 0x7714: L_7714: //B0 01 18
/* 006 [def:0001] [use:2001] */          if (C)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x7714);
/* 009 [def:0001] [use:0001] */              PC = 0x7717;
/*                           */              clockticks += 13;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7714);
/* 002 [def:0001] [use:0001] */      case 0x7716: L_7716: //18 A5 22
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7716);
/* 005 [def:0001] [use:0001] */      case 0x7717: L_7717: //A5 22 F0
/* 006 [def:0009] [use:0001] */          A=ram[0x0022];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7717);
/* 009 [def:0001] [use:0001] */      case 0x7719: L_7719: //F0 F2 B8
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7719);
/* 013 [def:0001] [use:0001] */              PC = 0x770d;
/*                           */              clockticks += 20;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7719);
/* 002 [def:0001] [use:0001] */      case 0x771B: L_771b: //B8 8A 48
/* 003 [def:0001] [use:0001] */          P &= 0xbf; /* CLV */
/* 004 [def:0001] [use:0001] */          //trace_PC(0x771B);
/* 005 [def:0001] [use:0001] */      case 0x771C: L_771c: //8A 48 A2
/* 006 [def:0001] [use:0001] */          A=X;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x771C);
/* 009 [def:0001] [use:0001] */      case 0x771D: L_771d: //48 A2 07
/* 010 [def:0001] [use:0001] */          stack[S--] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x771D);
/* 012 [def:0001] [use:0001] */      case 0x771E: L_771e: //A2 07 90
/* 013 [def:0001] [use:0001] */          X=0x07;
/* 014 [def:1801] [use:0010] */          ZN = X;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x771E);
/* 016 [def:0001] [use:0001] */      case 0x7720: L_7720: //90 04 B5
/* 017 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x7720);
/* 020 [def:0001] [use:0001] */              PC = 0x7726;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7720);
/* 002 [def:0001] [use:0001] */      case 0x7722: L_7722: //B5 9B D0
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x9b + X)];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7722);
/* 006 [def:0001] [use:0001] */      case 0x7724: L_7724: //D0 15 B9
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7724);
/* 010 [def:0001] [use:0001] */              PC = 0x773b;
/*                           */              clockticks += 38;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7724);
/* 002 [def:0001] [use:0001] */      case 0x7726: L_7726: //B9 C8 75
/* 003 [def:0009] [use:0021] */          A=ram[0x75C8 + Y /* can't wrap */];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7726);
/* 006 [def:0001] [use:0001] */      case 0x7729: L_7729: //F0 10 50
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7729);
/* 010 [def:0001] [use:0001] */              PC = 0x773b;
/*                           */              clockticks += 44;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7729);
/* 002 [def:0001] [use:0001] */      case 0x772B: L_772b: //50 02 A9
/* 003 [def:0001] [use:8000] */          if ((P & 0x40) == 0) /* BVC */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x772B);
/* 006 [def:0001] [use:0001] */              PC = 0x772f;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x772B);
/* 002 [def:0001] [use:0001] */      case 0x772D: L_772d: //A9 00 48
/* 003 [def:0008] [use:0000] */  //      A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x772D);
/* 006 [def:0001] [use:0001] */      case 0x772F: L_772f: //48 A9 00
/* 007 [def:0001] [use:0001] */          stack[S--] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x772F);
/* 009 [def:0001] [use:0001] */      case 0x7730: L_7730: //A9 00 95
/* 010 [def:0009] [use:0000] */          A=0x00;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7730);
/* 013 [def:0001] [use:0001] */      case 0x7732: L_7732: //95 9B A9
/* 014 [def:0001] [use:0019] */          ram[(unsigned char)(0x9b + X)] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7732);
/* 016 [def:0001] [use:0001] */      case 0x7734: L_7734: //A9 80 95
/* 017 [def:0009] [use:0000] */          A=0x80;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7734);
/* 020 [def:0001] [use:0001] */      case 0x7736: L_7736: //95 BB 68
/* 021 [def:0001] [use:0019] */          ram[(unsigned char)(0xbb + X)] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7736);
/* 023 [def:0001] [use:0001] */      case 0x7738: L_7738: //68 95 9B
/* 024 [def:0001] [use:0001] */          A=stack[++S];
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7738);
/* 027 [def:0001] [use:0001] */      case 0x7739: L_7739: //95 9B 88
/* 028 [def:0001] [use:0019] */          ram[(unsigned char)(0x9b + X)] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7739);
/* 030 [def:0001] [use:0001] */      case 0x773B: L_773b: //88 CA 10
/* 031 [def:0021] [use:0020] */          Y--;
/* 032 [def:1800] [use:0020] */  //      ZN = Y;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x773B);
/* 034 [def:0001] [use:0001] */      case 0x773C: L_773c: //CA 10 E1
/* 035 [def:0011] [use:0010] */          X--;
/* 036 [def:1801] [use:0010] */          ZN = X;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x773C);
/* 038 [def:0001] [use:0001] */      case 0x773D: L_773d: //10 E1 68
/* 039 [def:0001] [use:1001] */          if (ZN < 0)
/* 040 [def:0001] [use:0001] */          {
/* 041 [def:0001] [use:0001] */              //trace_PC(0x773D);
/* 042 [def:0001] [use:0001] */              PC = 0x7720;
/*                           */              clockticks += 80;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x773D);
/* 002 [def:0001] [use:0001] */      case 0x773F: L_773f: //68 AA 60
/* 003 [def:0001] [use:0001] */          A=stack[++S];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x773F);
/* 006 [def:0001] [use:0001] */      case 0x7740: L_7740: //AA 60 A2
/* 007 [def:0011] [use:0008] */          X=A;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7740);
/* 010 [def:0001] [use:0001] */      case 0x7741: L_7741: //60 A2 07
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7741);
/* 012 [def:0001] [use:0001] */          PC=stack[++S];
/* 013 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 014 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 91; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7742: L_7742: //A2 07 B4
/* 001 [def:0001] [use:0001] */          X=0x07;
/* 002 [def:1801] [use:0010] */          ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7742);
/* 004 [def:0001] [use:0001] */      case 0x7744: L_7744: //B4 9B F0
/* 005 [def:0001] [use:0011] */          temp=(0x009B + X)&0xFF;
/* 006 [def:0001] [use:0001] */          Y=ram[temp];
/* 007 [def:0001] [use:0001] */          DO_Z (Y);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7744);
/* 009 [def:0001] [use:0001] */      case 0x7746: L_7746: //F0 3A B5
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7746);
/* 013 [def:0001] [use:0001] */              PC = 0x7782;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7746);
/* 002 [def:0001] [use:0001] */      case 0x7748: L_7748: //B5 BB 30
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xbb + X)];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7748);
/* 006 [def:0001] [use:0001] */      case 0x774A: L_774a: //30 41 D6
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x774A);
/* 010 [def:0001] [use:0001] */              PC = 0x778d;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x774A);
/* 002 [def:0001] [use:0001] */      case 0x774C: L_774c: //D6 AB D0
/* 003 [def:0101] [use:0010] */          ZN=(0x00AB + X)&0xFF;
/* 004 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 005 [def:1901] [use:0100] */          ZN--;
/* 006 [def:0001] [use:0101] */          ram[ZN] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x774C);
/* 008 [def:0001] [use:0001] */      case 0x774E: L_774e: //D0 34 D6
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x774E);
/* 012 [def:0001] [use:0001] */              PC = 0x7784;
/*                           */              clockticks += 24;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x774E);
/* 002 [def:0001] [use:0001] */      case 0x7750: L_7750: //D6 B3 F0
/* 003 [def:0101] [use:0010] */          ZN=(0x00B3 + X)&0xFF;
/* 004 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 005 [def:1901] [use:0100] */          ZN--;
/* 006 [def:0001] [use:0101] */          ram[ZN] = ZN;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7750);
/* 008 [def:0001] [use:0001] */      case 0x7752: L_7752: //F0 09 B5
/* 009 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x7752);
/* 012 [def:0001] [use:0001] */              PC = 0x775d;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7752);
/* 002 [def:0001] [use:0001] */      case 0x7754: L_7754: //B5 A3 18
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xa3 + X)];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7754);
/* 006 [def:0001] [use:0001] */      case 0x7756: L_7756: //18 79 2A
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7756);
/* 009 [def:0001] [use:0001] */      case 0x7757: L_7757: //79 2A 76
/* 010 [def:b801] [use:6021] */          ADC(ram[(unsigned short)(0x762A + Y)]);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7757);
/* 012 [def:0001] [use:0001] */      case 0x775A: L_775a: //4C 6B 77
/* 013 [def:0001] [use:0001] */          //trace_PC(0x775A);
/* 014 [def:0001] [use:0001] */          PC = 0x776b;
/*                           */          clockticks += 44; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x775D: L_775d: //C8 C8 C8
/* 001 [def:0021] [use:0020] */          Y++;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x775D);
/* 004 [def:0001] [use:0001] */      case 0x775E: L_775e: //C8 C8 C8
/* 005 [def:0021] [use:0020] */          Y++;
/* 006 [def:1800] [use:0020] */  //      ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x775E);
/* 008 [def:0001] [use:0001] */      case 0x775F: L_775f: //C8 C8 94
/* 009 [def:0021] [use:0020] */          Y++;
/* 010 [def:1800] [use:0020] */  //      ZN = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x775F);
/* 012 [def:0001] [use:0001] */      case 0x7760: L_7760: //C8 94 9B
/* 013 [def:0021] [use:0020] */          Y++;
/* 014 [def:1800] [use:0020] */  //      ZN = Y;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7760);
/* 016 [def:0001] [use:0001] */      case 0x7761: L_7761: //94 9B B9
/* 017 [def:0001] [use:0011] */          temp=(0x009B + X)&0xFF;
/* 018 [def:0001] [use:0001] */          ram[temp] = Y;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7761);
/* 020 [def:0001] [use:0001] */      case 0x7763: L_7763: //B9 2B 76
/* 021 [def:0009] [use:0021] */          A=ram[0x762B + Y /* can't wrap */];
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7763);
/* 024 [def:0001] [use:0001] */      case 0x7766: L_7766: //95 B3 B9
/* 025 [def:0001] [use:0019] */          ram[(unsigned char)(0xb3 + X)] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7766);
/* 027 [def:0001] [use:0001] */      case 0x7768: L_7768: //B9 29 76
/* 028 [def:0009] [use:0021] */          A=ram[0x7629 + Y /* can't wrap */];
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x7768);
/* 031 [def:0001] [use:0001] */      case 0x776B: L_776b: //95 A3 B9
/* 032 [def:0001] [use:0019] */          ram[(unsigned char)(0xa3 + X)] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x776B);
/* 034 [def:0001] [use:0001] */      case 0x776D: L_776d: //B9 28 76
/* 035 [def:0009] [use:0021] */          A=ram[0x7628 + Y /* can't wrap */];
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x776D);
/* 038 [def:0001] [use:0001] */      case 0x7770: L_7770: //95 AB D0
/* 039 [def:0001] [use:0019] */          ram[(unsigned char)(0xab + X)] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7770);
/* 041 [def:0001] [use:0001] */      case 0x7772: L_7772: //D0 10 B4
/* 042 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 043 [def:0001] [use:0001] */          {
/* 044 [def:0001] [use:0001] */              //trace_PC(0x7772);
/* 045 [def:0001] [use:0001] */              PC = 0x7784;
/*                           */              clockticks += 39;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7772);
/* 002 [def:0001] [use:0001] */      case 0x7774: L_7774: //B4 C3 D6
/* 003 [def:0001] [use:0011] */          temp=(0x00C3 + X)&0xFF;
/* 004 [def:0001] [use:0001] */          Y=ram[temp];
/* 005 [def:0001] [use:0001] */          DO_Z (Y);
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7774);
/* 007 [def:0001] [use:0001] */      case 0x7776: L_7776: //D6 BB D0
/* 008 [def:0101] [use:0010] */          ZN=(0x00BB + X)&0xFF;
/* 009 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 010 [def:1901] [use:0100] */          ZN--;
/* 011 [def:0001] [use:0101] */          ram[ZN] = ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7776);
/* 013 [def:0001] [use:0001] */      case 0x7778: L_7778: //D0 E7 B4
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x7778);
/* 017 [def:0001] [use:0001] */              PC = 0x7761;
/*                           */              clockticks += 51;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7778);
/* 002 [def:0001] [use:0001] */      case 0x777A: L_777a: //B4 9B C8
/* 003 [def:0001] [use:0011] */          temp=(0x009B + X)&0xFF;
/* 004 [def:0001] [use:0001] */          Y=ram[temp];
/* 005 [def:0001] [use:0001] */          DO_Z (Y);
/* 006 [def:0001] [use:0001] */          //trace_PC(0x777A);
/* 007 [def:0001] [use:0001] */      case 0x777C: L_777c: //C8 D0 0E
/* 008 [def:0021] [use:0020] */          Y++;
/* 009 [def:1801] [use:0020] */          ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x777C);
/* 011 [def:0001] [use:0001] */      case 0x777D: L_777d: //D0 0E A8
/* 012 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x777D);
/* 015 [def:0001] [use:0001] */              PC = 0x778d;
/*                           */              clockticks += 59;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x777D);
/* 002 [def:0001] [use:0001] */      case 0x777F: L_777f: //A8 94 9B
/* 003 [def:0021] [use:0008] */          Y=A;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x777F);
/* 006 [def:0001] [use:0001] */      case 0x7780: L_7780: //94 9B 94
/* 007 [def:0001] [use:0011] */          temp=(0x009B + X)&0xFF;
/* 008 [def:0001] [use:0001] */          ram[temp] = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7780);
/* 010 [def:0001] [use:0001] */      case 0x7782: L_7782: //94 A3 B5
/* 011 [def:0001] [use:0011] */          temp=(0x00A3 + X)&0xFF;
/* 012 [def:0001] [use:0001] */          ram[temp] = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7782);
/* 014 [def:0001] [use:0001] */      case 0x7784: L_7784: //B5 A3 9D
/* 015 [def:0009] [use:0011] */          A=ram[(unsigned char)(0xa3 + X)];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7784);
/* 018 [def:0001] [use:0001] */      case 0x7786: L_7786: //9D 00 2C
/* 019 [def:0001] [use:0019] */          ram[0x2C00 + X /* can't wrap */] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7786);
/* 021 [def:0001] [use:0001] */      case 0x7789: L_7789: //CA 10 B8
/* 022 [def:0011] [use:0010] */          X--;
/* 023 [def:1801] [use:0010] */          ZN = X;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7789);
/* 025 [def:0001] [use:0001] */      case 0x778A: L_778a: //10 B8 60
/* 026 [def:0001] [use:1001] */          if (ZN < 0)
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x778A);
/* 029 [def:0001] [use:0001] */              PC = 0x7744;
/*                           */              clockticks += 82;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x778A);
/* 002 [def:0001] [use:0001] */      case 0x778C: L_778c: //60 B9 28
/* 003 [def:0001] [use:0001] */          //trace_PC(0x778C);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 87; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x778D: L_778d: //B9 28 76
/* 001 [def:0009] [use:0021] */          A=ram[0x7628 + Y /* can't wrap */];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x778D);
/* 004 [def:0001] [use:0001] */      case 0x7790: L_7790: //F0 ED 95
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7790);
/* 008 [def:0001] [use:0001] */              PC = 0x777f;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7790);
/* 002 [def:0001] [use:0001] */      case 0x7792: L_7792: //95 BB C8
/* 003 [def:0001] [use:0019] */          ram[(unsigned char)(0xbb + X)] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7792);
/* 005 [def:0001] [use:0001] */      case 0x7794: L_7794: //C8 94 C3
/* 006 [def:0021] [use:0020] */          Y++;
/* 007 [def:1801] [use:0020] */          ZN = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7794);
/* 009 [def:0001] [use:0001] */      case 0x7795: L_7795: //94 C3 D0
/* 010 [def:0001] [use:0011] */          temp=(0x00C3 + X)&0xFF;
/* 011 [def:0001] [use:0001] */          ram[temp] = Y;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7795);
/* 013 [def:0001] [use:0001] */      case 0x7797: L_7797: //D0 C8 01
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x7797);
/* 017 [def:0001] [use:0001] */              PC = 0x7761;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7797);
/* 002 [def:0001] [use:0001] */      case 0x7844: L_7844: //A9 00 A2
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7844);
/* 006 [def:0001] [use:0001] */      case 0x7846: L_7846: //A2 07 95
/* 007 [def:0001] [use:0001] */          X=0x07;
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7846);
/* 010 [def:0001] [use:0001] */      case 0x7848: L_7848: //95 9B CA
/* 011 [def:0001] [use:0019] */          ram[(unsigned char)(0x9b + X)] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7848);
/* 013 [def:0001] [use:0001] */      case 0x784A: L_784a: //CA 10 FB
/* 014 [def:0011] [use:0010] */          X--;
/* 015 [def:1801] [use:0010] */          ZN = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x784A);
/* 017 [def:0001] [use:0001] */      case 0x784B: L_784b: //10 FB 8D
/* 018 [def:0001] [use:1001] */          if (ZN < 0)
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x784B);
/* 021 [def:0001] [use:0001] */              PC = 0x7848;
/*                           */              clockticks += 33;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x784B);
/* 002 [def:0001] [use:0001] */      case 0x784D: L_784d: //8D 08 2C
/* 003 [def:0001] [use:0008] */          ram[0x2C08] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x784D);
/* 005 [def:0001] [use:0001] */      case 0x7850: L_7850: //60 2C FF
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7850);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 42; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7851: L_7851: //2C FF 01
/* 001 [def:1101] [use:0001] */          ZN=ram[0x01FF];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7851);
/* 005 [def:0001] [use:0001] */      case 0x7854: L_7854: //10 01 40
/* 006 [def:0001] [use:1001] */          if (ZN < 0)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x7854);
/* 009 [def:0001] [use:0001] */              PC = 0x7857;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7854);
/* 002 [def:0001] [use:0001] */      case 0x7856: L_7856: //40 48 98
/* 003 [def:0001] [use:0001] */          P = stack[++S] | 0x20; /* RTI - needs work */
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=((unsigned short)(stack[++S])<<8);
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7856);
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return; /* Pop address where interrupt came from */

/* 000 [def:0001] [use:0001] */      case 0x7857: L_7857: //48 98 48
/* 001 [def:0001] [use:0001] */          stack[S--] = A;
/* 002 [def:0001] [use:0001] */          //trace_PC(0x7857);
/* 003 [def:0001] [use:0001] */      case 0x7858: L_7858: //98 48 8A
/* 004 [def:0001] [use:0001] */          A=Y;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7858);
/* 007 [def:0001] [use:0001] */      case 0x7859: L_7859: //48 8A 48
/* 008 [def:0001] [use:0001] */          stack[S--] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7859);
/* 010 [def:0001] [use:0001] */      case 0x785A: L_785a: //8A 48 D8
/* 011 [def:0001] [use:0001] */          A=X;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x785A);
/* 014 [def:0001] [use:0001] */      case 0x785B: L_785b: //48 D8 AD
/* 015 [def:0001] [use:0001] */          stack[S--] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x785B);
/* 017 [def:0001] [use:0001] */      case 0x785C: L_785c: //D8 AD FF
/* 018 [def:0001] [use:0001] */          P &= 0xf7;  //cld
/* 019 [def:0001] [use:0001] */          //trace_PC(0x785C);
/* 020 [def:0001] [use:0001] */      case 0x785D: L_785d: //AD FF 01
/* 021 [def:0009] [use:0001] */          A=ram[0x01FF];
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x785D);
/* 024 [def:0001] [use:0001] */      case 0x7860: L_7860: //0D D0 01
/* 025 [def:0001] [use:0001] */          A|=ram[0x01D0];
/* 026 [def:1801] [use:0008] */          ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7860);
/* 028 [def:0001] [use:0001] */      case 0x7863: L_7863: //D0 FE E6
/* 029 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x7863);
/* 032 [def:0001] [use:0001] */              PC = 0x7863;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7863);
/* 002 [def:0001] [use:0001] */      case 0x7865: L_7865: //E6 78 A5
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x0078];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7865);
/* 005 [def:0001] [use:0001] */      case 0x7867: L_7867: //A5 78 29
/* 006 [def:0009] [use:0001] */          A=ram[0x0078];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7867);
/* 009 [def:0001] [use:0001] */      case 0x7869: L_7869: //29 03 D0
/* 010 [def:0009] [use:0008] */          A &= 0x03;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7869);
/* 013 [def:0001] [use:0001] */      case 0x786B: L_786b: //D0 0D E6
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x786B);
/* 017 [def:0001] [use:0001] */              PC = 0x787a;
/*                           */              clockticks += 39;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x786B);
/* 002 [def:0001] [use:0001] */      case 0x786D: L_786d: //E6 75 A5
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x0075];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x786D);
/* 005 [def:0001] [use:0001] */      case 0x786F: L_786f: //A5 75 C9
/* 006 [def:0009] [use:0001] */          A=ram[0x0075];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x786F);
/* 009 [def:0001] [use:0001] */      case 0x7871: L_7871: //C9 03 90
/* 010 [def:0101] [use:0000] */          ZN=0x03;
/* 011 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 012 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7871);
/* 014 [def:0001] [use:0001] */      case 0x7873: L_7873: //90 05 D0
/* 015 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7873);
/* 018 [def:0001] [use:0001] */              PC = 0x787a;
/*                           */              clockticks += 52;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7873);
/* 002 [def:0001] [use:0001] */      case 0x787A: L_787a: //A6 22 D0
/* 003 [def:0001] [use:0001] */          X=ram[0x0022];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x787A);
/* 006 [def:0001] [use:0001] */      case 0x787C: L_787c: //D0 1D A5
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x787C);
/* 010 [def:0001] [use:0001] */              PC = 0x789b;
/*                           */              clockticks += 57;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x787C);
/* 002 [def:0001] [use:0001] */      case 0x787E: L_787e: //A5 42 25
/* 003 [def:0009] [use:0001] */          A=ram[0x0042];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x787E);
/* 006 [def:0001] [use:0001] */      case 0x7880: L_7880: //25 43 10
/* 007 [def:0009] [use:0009] */          A &= ram[0x0043];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7880);
/* 010 [def:0001] [use:0001] */      case 0x7882: L_7882: //10 17 8E
/* 011 [def:0001] [use:1001] */          if (ZN < 0)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x7882);
/* 014 [def:0001] [use:0001] */              PC = 0x789b;
/*                           */              clockticks += 65;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7882);
/* 002 [def:0001] [use:0001] */      case 0x7884: L_7884: //8E 0F 2C
/* 003 [def:0001] [use:0001] */          ram[0x2C0F] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7884);
/* 005 [def:0001] [use:0001] */      case 0x7887: L_7887: //A2 04 CA
/* 006 [def:0001] [use:0001] */          X=0x04;
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7887);
/* 009 [def:0001] [use:0001] */      case 0x7889: L_7889: //CA D0 FD
/* 010 [def:0011] [use:0010] */          X--;
/* 011 [def:1801] [use:0010] */          ZN = X;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7889);
/* 013 [def:0001] [use:0001] */      case 0x788A: L_788a: //D0 FD A2
/* 014 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x788A);
/* 017 [def:0001] [use:0001] */              PC = 0x7889;
/*                           */              clockticks += 76;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x788A);
/* 002 [def:0001] [use:0001] */      case 0x788C: L_788c: //A2 07 8E
/* 003 [def:0001] [use:0001] */          X=0x07;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x788C);
/* 006 [def:0001] [use:0001] */      case 0x788E: L_788e: //8E 0F 2C
/* 007 [def:0001] [use:0001] */          ram[0x2C0F] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x788E);
/* 009 [def:0001] [use:0001] */      case 0x7891: L_7891: //8E 0B 2C
/* 010 [def:0001] [use:0001] */          ram[0x2C0B] = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7891);
/* 012 [def:0001] [use:0001] */      case 0x7894: L_7894: //AD 08 2C
/* 013 [def:0009] [use:0001] */          A=ram[0x2C08];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7894);
/* 016 [def:0001] [use:0001] */      case 0x7897: L_7897: //49 FF 85
/* 017 [def:0009] [use:0008] */          A ^= 0xFF;
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7897);
/* 020 [def:0001] [use:0001] */      case 0x7899: L_7899: //85 8D 20
/* 021 [def:0001] [use:0008] */          ram[0x008D] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7899);
/* 023 [def:0001] [use:0001] */      case 0x789B: L_789b: //20 42 77
/* 024 [def:0001] [use:0001] */          stack[S--] = 0x78;
/* 025 [def:0001] [use:0001] */          stack[S--] = 0x9D;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x789B);
/* 027 [def:0001] [use:0001] */          PC = 0x7742;
/*                           */          clockticks += 101; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x789E: L_789e: //A2 02 BD
/* 001 [def:0001] [use:0001] */          X=0x02;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x789E);
/* 004 [def:0001] [use:0001] */      case 0x78A0: L_78a0: //BD 00 24
/* 005 [def:0009] [use:0011] */          A=ram[0x2400 + X /* can't wrap */];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x78A0);
/* 008 [def:0001] [use:0001] */      case 0x78A3: L_78a3: //0A B5 96
/* 009 [def:2001] [use:0008] */          C = A & 0x80;
/* 010 [def:0008] [use:0008] */  //      A = A << 1;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x78A3);
/* 013 [def:0001] [use:0001] */      case 0x78A4: L_78a4: //B5 96 29
/* 014 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x96 + X)];
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x78A4);
/* 017 [def:0001] [use:0001] */      case 0x78A6: L_78a6: //29 1F 90
/* 018 [def:0009] [use:0008] */          A &= 0x1F;
/* 019 [def:1801] [use:0008] */          ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x78A6);
/* 021 [def:0001] [use:0001] */      case 0x78A8: L_78a8: //90 37 F0
/* 022 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 023 [def:0001] [use:0001] */          {
/* 024 [def:0001] [use:0001] */              //trace_PC(0x78A8);
/* 025 [def:0001] [use:0001] */              PC = 0x78e1;
/*                           */              clockticks += 19;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78A8);
/* 002 [def:0001] [use:0001] */      case 0x78BC: L_78bc: //95 96 AD
/* 003 [def:0001] [use:0019] */          ram[(unsigned char)(0x96 + X)] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x78BC);
/* 005 [def:0001] [use:0001] */      case 0x78BE: L_78be: //AD 06 20
/* 006 [def:0009] [use:0001] */          A=ram[0x2006];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x78BE);
/* 009 [def:0001] [use:0001] */      case 0x78C1: L_78c1: //29 80 F0
/* 010 [def:0009] [use:0008] */          A &= 0x80;
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x78C1);
/* 013 [def:0001] [use:0001] */      case 0x78C3: L_78c3: //F0 04 A9
/* 014 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x78C3);
/* 017 [def:0001] [use:0001] */              PC = 0x78c9;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78C3);
/* 002 [def:0001] [use:0001] */      case 0x78C9: L_78c9: //A5 8E F0
/* 003 [def:0009] [use:0001] */          A=ram[0x008E];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x78C9);
/* 006 [def:0001] [use:0001] */      case 0x78CB: L_78cb: //F0 08 C6
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x78CB);
/* 010 [def:0001] [use:0001] */              PC = 0x78d5;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78CB);
/* 002 [def:0001] [use:0001] */      case 0x78D5: L_78d5: //18 B5 93
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x78D5);
/* 005 [def:0001] [use:0001] */      case 0x78D6: L_78d6: //B5 93 F0
/* 006 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x93 + X)];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x78D6);
/* 009 [def:0001] [use:0001] */      case 0x78D8: L_78d8: //F0 23 D6
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x78D8);
/* 013 [def:0001] [use:0001] */              PC = 0x78fd;
/*                           */              clockticks += 45;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78D8);
/* 002 [def:0001] [use:0001] */      case 0x78E1: L_78e1: //C9 1B B0
/* 003 [def:0101] [use:0000] */          ZN=0x1B;
/* 004 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 005 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x78E1);
/* 007 [def:0001] [use:0001] */      case 0x78E3: L_78e3: //B0 09 B5
/* 008 [def:0001] [use:2001] */          if (C)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x78E3);
/* 011 [def:0001] [use:0001] */              PC = 0x78ee;
/*                           */              clockticks += 50;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78E3);
/* 002 [def:0001] [use:0001] */      case 0x78E5: L_78e5: //B5 96 69
/* 003 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x96 + X)];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x78E5);
/* 006 [def:0001] [use:0001] */      case 0x78E7: L_78e7: //69 20 90
/* 007 [def:b801] [use:6001] */          ADC(0x20);
/* 008 [def:0001] [use:0001] */          //trace_PC(0x78E7);
/* 009 [def:0001] [use:0001] */      case 0x78E9: L_78e9: //90 D1 F0
/* 010 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x78E9);
/* 013 [def:0001] [use:0001] */              PC = 0x78bc;
/*                           */              clockticks += 59;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78E9);
/* 002 [def:0001] [use:0001] */      case 0x78EB: L_78eb: //F0 01 18
/* 003 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x78EB);
/* 006 [def:0001] [use:0001] */              PC = 0x78ee;
/*                           */              clockticks += 61;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78EB);
/* 002 [def:0001] [use:0001] */      case 0x78EE: L_78ee: //A9 1F B0
/* 003 [def:0009] [use:0000] */          A=0x1F;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x78EE);
/* 006 [def:0001] [use:0001] */      case 0x78F0: L_78f0: //B0 CA 95
/* 007 [def:0001] [use:2001] */          if (C)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x78F0);
/* 010 [def:0001] [use:0001] */              PC = 0x78bc;
/*                           */              clockticks += 66;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78F0);
/* 002 [def:0001] [use:0001] */      case 0x78FD: L_78fd: //90 2A A9
/* 003 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x78FD);
/* 006 [def:0001] [use:0001] */              PC = 0x7929;
/*                           */              clockticks += 68;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x78FD);
/* 002 [def:0001] [use:0001] */      case 0x7929: L_7929: //CA 30 03
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7929);
/* 006 [def:0001] [use:0001] */      case 0x792A: L_792a: //30 03 4C
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x792A);
/* 010 [def:0001] [use:0001] */              PC = 0x792f;
/*                           */              clockticks += 72;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x792A);
/* 002 [def:0001] [use:0001] */      case 0x792C: L_792c: //4C A0 78
/* 003 [def:0001] [use:0001] */          //trace_PC(0x792C);
/* 004 [def:0001] [use:0001] */          PC = 0x78a0;
/*                           */          clockticks += 74; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x792F: L_792f: //A5 8D 4A
/* 001 [def:0009] [use:0001] */          A=ram[0x008D];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x792F);
/* 004 [def:0001] [use:0001] */      case 0x7931: L_7931: //4A 4A 4A
/* 005 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 006 [def:0009] [use:0008] */          A = A >> 1;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7931);
/* 009 [def:0001] [use:0001] */      case 0x7932: L_7932: //4A 4A 4A
/* 010 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 011 [def:0009] [use:0008] */          A = A >> 1;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7932);
/* 014 [def:0001] [use:0001] */      case 0x7933: L_7933: //4A 4A 4A
/* 015 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 016 [def:0009] [use:0008] */          A = A >> 1;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7933);
/* 019 [def:0001] [use:0001] */      case 0x7934: L_7934: //4A 4A A8
/* 020 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 021 [def:0009] [use:0008] */          A = A >> 1;
/* 022 [def:1800] [use:0008] */  //      ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7934);
/* 024 [def:0001] [use:0001] */      case 0x7935: L_7935: //4A A8 A5
/* 025 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 026 [def:0009] [use:0008] */          A = A >> 1;
/* 027 [def:1800] [use:0008] */  //      ZN = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x7935);
/* 029 [def:0001] [use:0001] */      case 0x7936: L_7936: //A8 A5 99
/* 030 [def:0021] [use:0008] */          Y=A;
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7936);
/* 033 [def:0001] [use:0001] */      case 0x7937: L_7937: //A5 99 38
/* 034 [def:0009] [use:0001] */          A=ram[0x0099];
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7937);
/* 037 [def:0001] [use:0001] */      case 0x7939: L_7939: //38 F9 A5
/* 038 [def:2001] [use:0000] */          C = 1;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x7939);
/* 040 [def:0001] [use:0001] */      case 0x793A: L_793a: //F9 A5 77
/* 041 [def:b801] [use:6021] */          SBC(ram[(unsigned short)(0x77A5 + Y)]);
/* 042 [def:0001] [use:0001] */          //trace_PC(0x793A);
/* 043 [def:0001] [use:0001] */      case 0x793D: L_793d: //30 0A 85
/* 044 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 045 [def:0001] [use:0001] */          {
/* 046 [def:0001] [use:0001] */              //trace_PC(0x793D);
/* 047 [def:0001] [use:0001] */              PC = 0x7949;
/*                           */              clockticks += 27;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x793D);
/* 002 [def:0001] [use:0001] */      case 0x7949: L_7949: //A5 8D 29
/* 003 [def:0009] [use:0001] */          A=ram[0x008D];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7949);
/* 006 [def:0001] [use:0001] */      case 0x794B: L_794b: //29 03 A8
/* 007 [def:0009] [use:0008] */          A &= 0x03;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x794B);
/* 010 [def:0001] [use:0001] */      case 0x794D: L_794d: //A8 F0 1A
/* 011 [def:0021] [use:0008] */          Y=A;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x794D);
/* 014 [def:0001] [use:0001] */      case 0x794E: L_794e: //F0 1A 4A
/* 015 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x794E);
/* 018 [def:0001] [use:0001] */              PC = 0x796a;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x794E);
/* 002 [def:0001] [use:0001] */      case 0x796A: L_796a: //85 8F A5
/* 003 [def:0001] [use:0008] */          ram[0x008F] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x796A);
/* 005 [def:0001] [use:0001] */      case 0x796C: L_796c: //A5 78 4A
/* 006 [def:0009] [use:0001] */          A=ram[0x0078];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x796C);
/* 009 [def:0001] [use:0001] */      case 0x796E: L_796e: //4A B0 27
/* 010 [def:2001] [use:0008] */          C = A & 0x01;
/* 011 [def:0009] [use:0008] */          A = A >> 1;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x796E);
/* 014 [def:0001] [use:0001] */      case 0x796F: L_796f: //B0 27 A0
/* 015 [def:0001] [use:2001] */          if (C)
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x796F);
/* 018 [def:0001] [use:0001] */              PC = 0x7998;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x796F);
/* 002 [def:0001] [use:0001] */      case 0x7971: L_7971: //A0 00 A2
/* 003 [def:0021] [use:0000] */          Y=0x00;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7971);
/* 006 [def:0001] [use:0001] */      case 0x7973: L_7973: //A2 02 B5
/* 007 [def:0001] [use:0001] */          X=0x02;
/* 008 [def:1800] [use:0010] */  //      ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7973);
/* 010 [def:0001] [use:0001] */      case 0x7975: L_7975: //B5 90 F0
/* 011 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x90 + X)];
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7975);
/* 014 [def:0001] [use:0001] */      case 0x7977: L_7977: //F0 09 C9
/* 015 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7977);
/* 018 [def:0001] [use:0001] */              PC = 0x7982;
/*                           */              clockticks += 58;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7977);
/* 002 [def:0001] [use:0001] */      case 0x7982: L_7982: //CA 10 F0
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7982);
/* 006 [def:0001] [use:0001] */      case 0x7983: L_7983: //10 F0 98
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7983);
/* 010 [def:0001] [use:0001] */              PC = 0x7975;
/*                           */              clockticks += 62;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7983);
/* 002 [def:0001] [use:0001] */      case 0x7985: L_7985: //98 D0 10
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7985);
/* 006 [def:0001] [use:0001] */      case 0x7986: L_7986: //D0 10 A2
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7986);
/* 010 [def:0001] [use:0001] */              PC = 0x7998;
/*                           */              clockticks += 66;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7986);
/* 002 [def:0001] [use:0001] */      case 0x7988: L_7988: //A2 02 B5
/* 003 [def:0001] [use:0001] */          X=0x02;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7988);
/* 006 [def:0001] [use:0001] */      case 0x798A: L_798a: //B5 90 F0
/* 007 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x90 + X)];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x798A);
/* 010 [def:0001] [use:0001] */      case 0x798C: L_798c: //F0 07 18
/* 011 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x798C);
/* 014 [def:0001] [use:0001] */              PC = 0x7995;
/*                           */              clockticks += 75;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x798C);
/* 002 [def:0001] [use:0001] */      case 0x7995: L_7995: //CA 10 F2
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7995);
/* 006 [def:0001] [use:0001] */      case 0x7996: L_7996: //10 F2 A5
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7996);
/* 010 [def:0001] [use:0001] */              PC = 0x798a;
/*                           */              clockticks += 79;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7996);
/* 002 [def:0001] [use:0001] */      case 0x7998: L_7998: //A5 90 8D
/* 003 [def:0009] [use:0001] */          A=ram[0x0090];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7998);
/* 006 [def:0001] [use:0001] */      case 0x799A: L_799a: //8D 05 3C
/* 007 [def:0001] [use:0008] */          ram[0x3C05] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x799A);
/* 009 [def:0001] [use:0001] */      case 0x799D: L_799d: //A5 91 8D
/* 010 [def:0009] [use:0001] */          A=ram[0x0091];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x799D);
/* 013 [def:0001] [use:0001] */      case 0x799F: L_799f: //8D 06 3C
/* 014 [def:0001] [use:0008] */          ram[0x3C06] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x799F);
/* 016 [def:0001] [use:0001] */      case 0x79A2: L_79a2: //A5 92 8D
/* 017 [def:0009] [use:0001] */          A=ram[0x0092];
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x79A2);
/* 020 [def:0001] [use:0001] */      case 0x79A4: L_79a4: //8D 07 3C
/* 021 [def:0001] [use:0008] */          ram[0x3C07] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x79A4);
/* 023 [def:0001] [use:0001] */      case 0x79A7: L_79a7: //A5 85 49
/* 024 [def:0009] [use:0001] */          A=ram[0x0085];
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x79A7);
/* 027 [def:0001] [use:0001] */      case 0x79A9: L_79a9: //49 03 6A
/* 028 [def:0009] [use:0008] */          A ^= 0x03;
/* 029 [def:1800] [use:0008] */  //      ZN = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x79A9);
/* 031 [def:0001] [use:0001] */      case 0x79AB: L_79ab: //6A 6A 8D
/* 032 [def:10001] [use:2000] */          saveflags = C;
/* 033 [def:2001] [use:0008] */          C = A & 0x01;
/* 034 [def:0009] [use:0008] */          A = A >> 1;
/* 035 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 036 [def:1800] [use:0008] */  //      ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x79AB);
/* 038 [def:0001] [use:0001] */      case 0x79AC: L_79ac: //6A 8D 00
/* 039 [def:10001] [use:2000] */          saveflags = C;
/* 040 [def:2001] [use:0008] */          C = A & 0x01;
/* 041 [def:0009] [use:0008] */          A = A >> 1;
/* 042 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x79AC);
/* 045 [def:0001] [use:0001] */      case 0x79AD: L_79ad: //8D 00 3C
/* 046 [def:0001] [use:0008] */          ram[0x3C00] = A;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x79AD);
/* 048 [def:0001] [use:0001] */      case 0x79B0: L_79b0: //6A 8D 01
/* 049 [def:10001] [use:2000] */          saveflags = C;
/* 050 [def:2001] [use:0008] */          C = A & 0x01;
/* 051 [def:0009] [use:0008] */          A = A >> 1;
/* 052 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 053 [def:1800] [use:0008] */  //      ZN = A;
/* 054 [def:0001] [use:0001] */          //trace_PC(0x79B0);
/* 055 [def:0001] [use:0001] */      case 0x79B1: L_79b1: //8D 01 3C
/* 056 [def:0001] [use:0008] */          ram[0x3C01] = A;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x79B1);
/* 058 [def:0001] [use:0001] */      case 0x79B4: L_79b4: //A5 8E F0
/* 059 [def:0009] [use:0001] */          A=ram[0x008E];
/* 060 [def:1801] [use:0008] */          ZN = A;
/* 061 [def:0001] [use:0001] */          //trace_PC(0x79B4);
/* 062 [def:0001] [use:0001] */      case 0x79B6: L_79b6: //F0 0A A9
/* 063 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 064 [def:0001] [use:0001] */          {
/* 065 [def:0001] [use:0001] */              //trace_PC(0x79B6);
/* 066 [def:0001] [use:0001] */              PC = 0x79c2;
/*                           */              clockticks += 125;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79B6);
/* 002 [def:0001] [use:0001] */      case 0x79C2: L_79c2: //A9 00 0E
/* 003 [def:0009] [use:0000] */          A=0x00;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79C2);
/* 006 [def:0001] [use:0001] */      case 0x79C4: L_79c4: //0E 04 20
/* 007 [def:0101] [use:0001] */          ZN=ram[0x2004];
/* 008 [def:2001] [use:0100] */          C = ZN & 0x80;
/* 009 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 010 [def:0001] [use:0100] */          ram[0x2004] = ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x79C4);
/* 012 [def:0001] [use:0001] */      case 0x79C7: L_79c7: //90 05 A5
/* 013 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x79C7);
/* 016 [def:0001] [use:0001] */              PC = 0x79ce;
/*                           */              clockticks += 136;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79C7);
/* 002 [def:0001] [use:0001] */      case 0x79C9: L_79c9: //A5 FE 09
/* 003 [def:0009] [use:0001] */          A=ram[0x00FE];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79C9);
/* 006 [def:0001] [use:0001] */      case 0x79CB: L_79cb: //09 08 0A
/* 007 [def:0001] [use:0001] */          A |= 0x08;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x79CB);
/* 010 [def:0001] [use:0001] */      case 0x79CD: L_79cd: //0A 85 FE
/* 011 [def:2001] [use:0008] */          C = A & 0x80;
/* 012 [def:0009] [use:0008] */          A = A << 1;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x79CD);
/* 015 [def:0001] [use:0001] */      case 0x79CE: L_79ce: //85 FE 68
/* 016 [def:0001] [use:0008] */          ram[0x00FE] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x79CE);
/* 018 [def:0001] [use:0001] */      case 0x79D0: L_79d0: //68 AA 68
/* 019 [def:0001] [use:0001] */          A=stack[++S];
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x79D0);
/* 022 [def:0001] [use:0001] */      case 0x79D1: L_79d1: //AA 68 A8
/* 023 [def:0011] [use:0008] */          X=A;
/* 024 [def:1800] [use:0008] */  //      ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x79D1);
/* 026 [def:0001] [use:0001] */      case 0x79D2: L_79d2: //68 A8 68
/* 027 [def:0001] [use:0001] */          A=stack[++S];
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x79D2);
/* 030 [def:0001] [use:0001] */      case 0x79D3: L_79d3: //A8 68 40
/* 031 [def:0021] [use:0008] */          Y=A;
/* 032 [def:1800] [use:0008] */  //      ZN = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x79D3);
/* 034 [def:0001] [use:0001] */      case 0x79D4: L_79d4: //68 40 A9
/* 035 [def:0001] [use:0001] */          A=stack[++S];
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x79D4);
/* 038 [def:0001] [use:0001] */      case 0x79D5: L_79d5: //40 A9 D0
/* 039 [def:0001] [use:0001] */          P = stack[++S] | 0x20; /* RTI - needs work */
/* 040 [def:0001] [use:0001] */          PC=stack[++S];
/* 041 [def:0001] [use:0001] */          PC|=((unsigned short)(stack[++S])<<8);
/* 042 [def:0001] [use:0001] */          //trace_PC(0x79D5);
/*                           */          clockticks += 167; /*poll_nmi(opadd);*/
/*                           */          return; /* Pop address where interrupt came from */

/* 000 [def:0001] [use:0001] */      case 0x79D6: L_79d6: //A9 D0 D0
/* 001 [def:0009] [use:0000] */          A=0xD0;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x79D6);
/* 004 [def:0001] [use:0001] */      case 0x79D8: L_79d8: //D0 02 A9
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x79D8);
/* 008 [def:0001] [use:0001] */              PC = 0x79dc;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79D8);
/* 002 [def:0001] [use:0001] */      case 0x79DA: L_79da: //A9 B0 A0
/* 003 [def:0009] [use:0000] */          A=0xB0;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79DA);
/* 006 [def:0001] [use:0001] */      case 0x79DC: L_79dc: //A0 00 91
/* 007 [def:0021] [use:0000] */          Y=0x00;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x79DC);
/* 010 [def:0001] [use:0001] */      case 0x79DE: L_79de: //91 03 C8
/* 011 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 012 [def:0001] [use:0001] */          //trace_PC(0x79DE);
/* 013 [def:0001] [use:0001] */      case 0x79E0: L_79e0: //C8 91 03
/* 014 [def:0021] [use:0020] */          Y++;
/* 015 [def:1801] [use:0020] */          ZN = Y;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x79E0);
/* 017 [def:0001] [use:0001] */      case 0x79E1: L_79e1: //91 03 D0
/* 018 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 019 [def:0001] [use:0001] */          //trace_PC(0x79E1);
/* 020 [def:0001] [use:0001] */      case 0x79E3: L_79e3: //D0 70 90
/* 021 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x79E3);
/* 024 [def:0001] [use:0001] */              PC = 0x7a55;
/*                           */              clockticks += 28;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79E3);
/* 002 [def:0001] [use:0001] */      case 0x79E5: L_79e5: //90 04 29
/* 003 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x79E5);
/* 006 [def:0001] [use:0001] */              PC = 0x79eb;
/*                           */              clockticks += 30;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79E5);
/* 002 [def:0001] [use:0001] */      case 0x79E7: L_79e7: //29 0F F0
/* 003 [def:0009] [use:0008] */          A &= 0x0F;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79E7);
/* 006 [def:0001] [use:0001] */      case 0x79E9: L_79e9: //F0 05 29
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x79E9);
/* 010 [def:0001] [use:0001] */              PC = 0x79f0;
/*                           */              clockticks += 35;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79E9);
/* 002 [def:0001] [use:0001] */      case 0x79EB: L_79eb: //29 0F 18
/* 003 [def:0009] [use:0008] */          A &= 0x0F;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79EB);
/* 006 [def:0001] [use:0001] */      case 0x79ED: L_79ed: //18 69 01
/* 007 [def:2001] [use:0000] */          C = 0;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x79ED);
/* 009 [def:0001] [use:0001] */      case 0x79EE: L_79ee: //69 01 08
/* 010 [def:b801] [use:6001] */          ADC(0x01);
/* 011 [def:0001] [use:0001] */          //trace_PC(0x79EE);
/* 012 [def:0001] [use:0001] */      case 0x79F0: L_79f0: //08 0A A8
/* 013 [def:0081] [use:f881] */          stack[S--] = P; // todo: consolidate ZN, C
/* 014 [def:0001] [use:0001] */          //trace_PC(0x79F0);
/* 015 [def:0001] [use:0001] */      case 0x79F1: L_79f1: //0A A8 20
/* 016 [def:2001] [use:0008] */          C = A & 0x80;
/* 017 [def:0009] [use:0008] */          A = A << 1;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x79F1);
/* 020 [def:0001] [use:0001] */      case 0x79F2: L_79f2: //A8 20 F8
/* 021 [def:0021] [use:0008] */          Y=A;
/* 022 [def:1801] [use:0008] */          ZN = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x79F2);
/* 024 [def:0001] [use:0001] */      case 0x79F3: L_79f3: //20 F8 79
/* 025 [def:0001] [use:0001] */          stack[S--] = 0x79;
/* 026 [def:0001] [use:0001] */          stack[S--] = 0xF5;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x79F3);
/* 028 [def:0001] [use:0001] */          PC = 0x79f8;
/*                           */          clockticks += 55; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x79F6: L_79f6: //28 60 C0
/* 001 [def:f881] [use:0081] */          P=stack[++S]; // todo: set C, ZN
/* 002 [def:f801] [use:f800] */          P |= 0x20; /* PLP - needs work */
/* 003 [def:0001] [use:0001] */          //trace_PC(0x79F6);
/* 004 [def:0001] [use:0001] */      case 0x79F7: L_79f7: //60 C0 4A
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79F7);
/* 006 [def:0001] [use:0001] */          PC=stack[++S];
/* 007 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 008 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 10; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x79F8: L_79f8: //C0 4A 90
/* 001 [def:0101] [use:0001] */          ZN=0x4A;
/* 002 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 003 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x79F8);
/* 005 [def:0001] [use:0001] */      case 0x79FA: L_79fa: //90 02 A0
/* 006 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x79FA);
/* 009 [def:0001] [use:0001] */              PC = 0x79fe;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x79FA);
/* 002 [def:0001] [use:0001] */      case 0x79FE: L_79fe: //BE F9 56
/* 003 [def:0001] [use:0021] */          X=ram[(unsigned short)(0x56F9 + Y)];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x79FE);
/* 006 [def:0001] [use:0001] */      case 0x7A01: L_7a01: //B9 F8 56
/* 007 [def:0009] [use:0021] */          A=ram[0x56F8 + Y /* can't wrap */];
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7A01);
/* 010 [def:0001] [use:0001] */      case 0x7A04: L_7a04: //4C D5 7C
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7A04);
/* 012 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 16; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7A0C: L_7a0c: //A0 01 91
/* 001 [def:0021] [use:0000] */          Y=0x01;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7A0C);
/* 004 [def:0001] [use:0001] */      case 0x7A0E: L_7a0e: //91 03 88
/* 005 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7A0E);
/* 007 [def:0001] [use:0001] */      case 0x7A10: L_7a10: //88 8A 6A
/* 008 [def:0021] [use:0020] */          Y--;
/* 009 [def:1800] [use:0020] */  //      ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7A10);
/* 011 [def:0001] [use:0001] */      case 0x7A11: L_7a11: //8A 6A 91
/* 012 [def:0001] [use:0001] */          A=X;
/* 013 [def:1800] [use:0008] */  //      ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7A11);
/* 015 [def:0001] [use:0001] */      case 0x7A12: L_7a12: //6A 91 03
/* 016 [def:10001] [use:2000] */          saveflags = C;
/* 017 [def:2001] [use:0008] */          C = A & 0x01;
/* 018 [def:0009] [use:0008] */          A = A >> 1;
/* 019 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7A12);
/* 022 [def:0001] [use:0001] */      case 0x7A13: L_7a13: //91 03 C8
/* 023 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7A13);
/* 025 [def:0001] [use:0001] */      case 0x7A15: L_7a15: //C8 D0 3D
/* 026 [def:0021] [use:0020] */          Y++;
/* 027 [def:1801] [use:0020] */          ZN = Y;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x7A15);
/* 029 [def:0001] [use:0001] */      case 0x7A16: L_7a16: //D0 3D 4A
/* 030 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 031 [def:0001] [use:0001] */          {
/* 032 [def:0001] [use:0001] */              //trace_PC(0x7A16);
/* 033 [def:0001] [use:0001] */              PC = 0x7a55;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7A16);
/* 002 [def:0001] [use:0001] */      case 0x7A18: L_7a18: //4A 29 0F
/* 003 [def:2001] [use:0008] */          C = A & 0x01;
/* 004 [def:0009] [use:0008] */          A = A >> 1;
/* 005 [def:1800] [use:0008] */  //      ZN = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7A18);
/* 007 [def:0001] [use:0001] */      case 0x7A19: L_7a19: //29 0F 09
/* 008 [def:0009] [use:0008] */          A &= 0x0F;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7A19);
/* 011 [def:0001] [use:0001] */      case 0x7A1B: L_7a1b: //09 C0 D0
/* 012 [def:0001] [use:0001] */          A |= 0xC0;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7A1B);
/* 015 [def:0001] [use:0001] */      case 0x7A1D: L_7a1d: //D0 ED A0
/* 016 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x7A1D);
/* 019 [def:0001] [use:0001] */              PC = 0x7a0c;
/*                           */              clockticks += 36;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7A1D);
/* 002 [def:0001] [use:0001] */      case 0x7A1F: L_7a1f: //A0 00 84
/* 003 [def:0021] [use:0000] */          Y=0x00;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7A1F);
/* 006 [def:0001] [use:0001] */      case 0x7A21: L_7a21: //84 06 84
/* 007 [def:0001] [use:0020] */          ram[0x0006] = Y;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7A21);
/* 009 [def:0001] [use:0001] */      case 0x7A23: L_7a23: //84 08 0A
/* 010 [def:0001] [use:0020] */          ram[0x0008] = Y;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7A23);
/* 012 [def:0001] [use:0001] */      case 0x7A25: L_7a25: //0A 26 06
/* 013 [def:2001] [use:0008] */          C = A & 0x80;
/* 014 [def:0009] [use:0008] */          A = A << 1;
/* 015 [def:1800] [use:0008] */  //      ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7A25);
/* 017 [def:0001] [use:0001] */      case 0x7A26: L_7a26: //26 06 0A
/* 018 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 019 [def:0101] [use:0001] */          ZN=ram[0x0006];
/* 020 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 021 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 022 [def:1801] [use:10100] */          ZN |= saveflags;
/* 023 [def:0001] [use:1800] */          ram[0x0006] = ZN;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7A26);
/* 025 [def:0001] [use:0001] */      case 0x7A28: L_7a28: //0A 26 06
/* 026 [def:2001] [use:0008] */          C = A & 0x80;
/* 027 [def:0009] [use:0008] */          A = A << 1;
/* 028 [def:1800] [use:0008] */  //      ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7A28);
/* 030 [def:0001] [use:0001] */      case 0x7A29: L_7a29: //26 06 85
/* 031 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 032 [def:0101] [use:0001] */          ZN=ram[0x0006];
/* 033 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 034 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 035 [def:1801] [use:10100] */          ZN |= saveflags;
/* 036 [def:0001] [use:1800] */          ram[0x0006] = ZN;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x7A29);
/* 038 [def:0001] [use:0001] */      case 0x7A2B: L_7a2b: //85 05 8A
/* 039 [def:0001] [use:0008] */          ram[0x0005] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7A2B);
/* 041 [def:0001] [use:0001] */      case 0x7A2D: L_7a2d: //8A 0A 26
/* 042 [def:0001] [use:0001] */          A=X;
/* 043 [def:1800] [use:0008] */  //      ZN = A;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x7A2D);
/* 045 [def:0001] [use:0001] */      case 0x7A2E: L_7a2e: //0A 26 08
/* 046 [def:2001] [use:0008] */          C = A & 0x80;
/* 047 [def:0009] [use:0008] */          A = A << 1;
/* 048 [def:1800] [use:0008] */  //      ZN = A;
/* 049 [def:0001] [use:0001] */          //trace_PC(0x7A2E);
/* 050 [def:0001] [use:0001] */      case 0x7A2F: L_7a2f: //26 08 0A
/* 051 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 052 [def:0101] [use:0001] */          ZN=ram[0x0008];
/* 053 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 054 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 055 [def:1801] [use:10100] */          ZN |= saveflags;
/* 056 [def:0001] [use:1800] */          ram[0x0008] = ZN;
/* 057 [def:0001] [use:0001] */          //trace_PC(0x7A2F);
/* 058 [def:0001] [use:0001] */      case 0x7A31: L_7a31: //0A 26 08
/* 059 [def:2001] [use:0008] */          C = A & 0x80;
/* 060 [def:0009] [use:0008] */          A = A << 1;
/* 061 [def:1800] [use:0008] */  //      ZN = A;
/* 062 [def:0001] [use:0001] */          //trace_PC(0x7A31);
/* 063 [def:0001] [use:0001] */      case 0x7A32: L_7a32: //26 08 85
/* 064 [def:10001] [use:2000] */          saveflags=(C != 0 ? 1 : 0);
/* 065 [def:0101] [use:0001] */          ZN=ram[0x0008];
/* 066 [def:2000] [use:0100] */  //      C = ZN & 0x80;
/* 067 [def:0101] [use:0100] */          ZN = ZN << 1;
/* 068 [def:1801] [use:10100] */          ZN |= saveflags;
/* 069 [def:0001] [use:1800] */          ram[0x0008] = ZN;
/* 070 [def:0001] [use:0001] */          //trace_PC(0x7A32);
/* 071 [def:0001] [use:0001] */      case 0x7A34: L_7a34: //85 07 A2
/* 072 [def:0001] [use:0008] */          ram[0x0007] = A;
/* 073 [def:0001] [use:0001] */          //trace_PC(0x7A34);
/* 074 [def:0001] [use:0001] */      case 0x7A36: L_7a36: //A2 05 B5
/* 075 [def:0001] [use:0001] */          X=0x05;
/* 076 [def:1800] [use:0010] */  //      ZN = X;
/* 077 [def:0001] [use:0001] */          //trace_PC(0x7A36);
/* 078 [def:0001] [use:0001] */      case 0x7A38: L_7a38: //B5 02 A0
/* 079 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x02 + X)];
/* 080 [def:1800] [use:0008] */  //      ZN = A;
/* 081 [def:0001] [use:0001] */          //trace_PC(0x7A38);
/* 082 [def:0001] [use:0001] */      case 0x7A3A: L_7a3a: //A0 00 91
/* 083 [def:0021] [use:0000] */          Y=0x00;
/* 084 [def:1800] [use:0020] */  //      ZN = Y;
/* 085 [def:0001] [use:0001] */          //trace_PC(0x7A3A);
/* 086 [def:0001] [use:0001] */      case 0x7A3C: L_7a3c: //91 03 B5
/* 087 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 088 [def:0001] [use:0001] */          //trace_PC(0x7A3C);
/* 089 [def:0001] [use:0001] */      case 0x7A3E: L_7a3e: //B5 03 29
/* 090 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x03 + X)];
/* 091 [def:1800] [use:0008] */  //      ZN = A;
/* 092 [def:0001] [use:0001] */          //trace_PC(0x7A3E);
/* 093 [def:0001] [use:0001] */      case 0x7A40: L_7a40: //29 0F 09
/* 094 [def:0009] [use:0008] */          A &= 0x0F;
/* 095 [def:1800] [use:0008] */  //      ZN = A;
/* 096 [def:0001] [use:0001] */          //trace_PC(0x7A40);
/* 097 [def:0001] [use:0001] */      case 0x7A42: L_7a42: //09 A0 C8
/* 098 [def:0001] [use:0001] */          A |= 0xA0;
/* 099 [def:1800] [use:0008] */  //      ZN = A;
/* 100 [def:0001] [use:0001] */          //trace_PC(0x7A42);
/* 101 [def:0001] [use:0001] */      case 0x7A44: L_7a44: //C8 91 03
/* 102 [def:0021] [use:0020] */          Y++;
/* 103 [def:1800] [use:0020] */  //      ZN = Y;
/* 104 [def:0001] [use:0001] */          //trace_PC(0x7A44);
/* 105 [def:0001] [use:0001] */      case 0x7A45: L_7a45: //91 03 B5
/* 106 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 107 [def:0001] [use:0001] */          //trace_PC(0x7A45);
/* 108 [def:0001] [use:0001] */      case 0x7A47: L_7a47: //B5 00 C8
/* 109 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x00 + X)];
/* 110 [def:1800] [use:0008] */  //      ZN = A;
/* 111 [def:0001] [use:0001] */          //trace_PC(0x7A47);
/* 112 [def:0001] [use:0001] */      case 0x7A49: L_7a49: //C8 91 03
/* 113 [def:0021] [use:0020] */          Y++;
/* 114 [def:1800] [use:0020] */  //      ZN = Y;
/* 115 [def:0001] [use:0001] */          //trace_PC(0x7A49);
/* 116 [def:0001] [use:0001] */      case 0x7A4A: L_7a4a: //91 03 B5
/* 117 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 118 [def:0001] [use:0001] */          //trace_PC(0x7A4A);
/* 119 [def:0001] [use:0001] */      case 0x7A4C: L_7a4c: //B5 01 29
/* 120 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x01 + X)];
/* 121 [def:1800] [use:0008] */  //      ZN = A;
/* 122 [def:0001] [use:0001] */          //trace_PC(0x7A4C);
/* 123 [def:0001] [use:0001] */      case 0x7A4E: L_7a4e: //29 0F 05
/* 124 [def:0009] [use:0008] */          A &= 0x0F;
/* 125 [def:1800] [use:0008] */  //      ZN = A;
/* 126 [def:0001] [use:0001] */          //trace_PC(0x7A4E);
/* 127 [def:0001] [use:0001] */      case 0x7A50: L_7a50: //05 01 C8
/* 128 [def:0009] [use:0009] */          A|=ram[0x0001];
/* 129 [def:1800] [use:0008] */  //      ZN = A;
/* 130 [def:0001] [use:0001] */          //trace_PC(0x7A50);
/* 131 [def:0001] [use:0001] */      case 0x7A52: L_7a52: //C8 91 03
/* 132 [def:0021] [use:0020] */          Y++;
/* 133 [def:1800] [use:0020] */  //      ZN = Y;
/* 134 [def:0001] [use:0001] */          //trace_PC(0x7A52);
/* 135 [def:0001] [use:0001] */      case 0x7A53: L_7a53: //91 03 98
/* 136 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 137 [def:0001] [use:0001] */          //trace_PC(0x7A53);
/* 138 [def:0001] [use:0001] */      case 0x7A55: L_7a55: //98 38 65
/* 139 [def:0001] [use:0001] */          A=Y;
/* 140 [def:1800] [use:0008] */  //      ZN = A;
/* 141 [def:0001] [use:0001] */          //trace_PC(0x7A55);
/* 142 [def:0001] [use:0001] */      case 0x7A56: L_7a56: //38 65 03
/* 143 [def:2001] [use:0000] */          C = 1;
/* 144 [def:0001] [use:0001] */          //trace_PC(0x7A56);
/* 145 [def:0001] [use:0001] */      case 0x7A57: L_7a57: //65 03 85
/* 146 [def:b801] [use:6001] */          ADC(ram[0x0003]);
/* 147 [def:0001] [use:0001] */          //trace_PC(0x7A57);
/* 148 [def:0001] [use:0001] */      case 0x7A59: L_7a59: //85 03 90
/* 149 [def:0001] [use:0008] */          ram[0x0003] = A;
/* 150 [def:0001] [use:0001] */          //trace_PC(0x7A59);
/* 151 [def:0001] [use:0001] */      case 0x7A5B: L_7a5b: //90 02 E6
/* 152 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 153 [def:0001] [use:0001] */          {
/* 154 [def:0001] [use:0001] */              //trace_PC(0x7A5B);
/* 155 [def:0001] [use:0001] */              PC = 0x7a5f;
/*                           */              clockticks += 152;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7A5B);
/* 002 [def:0001] [use:0001] */      case 0x7A5D: L_7a5d: //E6 04 60
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x0004];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7A5D);
/* 005 [def:0001] [use:0001] */      case 0x7A5F: L_7a5f: //60 A2 00
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7A5F);
/* 007 [def:0001] [use:0001] */          PC=stack[++S];
/* 008 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 009 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 162; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7AEA: L_7aea: //A2 00 A0
/* 001 [def:0001] [use:0001] */          X=0x00;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7AEA);
/* 004 [def:0001] [use:0001] */      case 0x7AEC: L_7aec: //A0 01 91
/* 005 [def:0021] [use:0000] */          Y=0x01;
/* 006 [def:1800] [use:0020] */  //      ZN = Y;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7AEC);
/* 008 [def:0001] [use:0001] */      case 0x7AEE: L_7aee: //91 03 88
/* 009 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7AEE);
/* 011 [def:0001] [use:0001] */      case 0x7AF0: L_7af0: //88 98 91
/* 012 [def:0021] [use:0020] */          Y--;
/* 013 [def:1800] [use:0020] */  //      ZN = Y;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7AF0);
/* 015 [def:0001] [use:0001] */      case 0x7AF1: L_7af1: //98 91 03
/* 016 [def:0001] [use:0001] */          A=Y;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7AF1);
/* 019 [def:0001] [use:0001] */      case 0x7AF2: L_7af2: //91 03 C8
/* 020 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7AF2);
/* 022 [def:0001] [use:0001] */      case 0x7AF4: L_7af4: //C8 C8 91
/* 023 [def:0021] [use:0020] */          Y++;
/* 024 [def:1800] [use:0020] */  //      ZN = Y;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7AF4);
/* 026 [def:0001] [use:0001] */      case 0x7AF5: L_7af5: //C8 91 03
/* 027 [def:0021] [use:0020] */          Y++;
/* 028 [def:1800] [use:0020] */  //      ZN = Y;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7AF5);
/* 030 [def:0001] [use:0001] */      case 0x7AF6: L_7af6: //91 03 C8
/* 031 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7AF6);
/* 033 [def:0001] [use:0001] */      case 0x7AF8: L_7af8: //C8 8A 91
/* 034 [def:0021] [use:0020] */          Y++;
/* 035 [def:1800] [use:0020] */  //      ZN = Y;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7AF8);
/* 037 [def:0001] [use:0001] */      case 0x7AF9: L_7af9: //8A 91 03
/* 038 [def:0001] [use:0001] */          A=X;
/* 039 [def:1801] [use:0008] */          ZN = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7AF9);
/* 041 [def:0001] [use:0001] */      case 0x7AFA: L_7afa: //91 03 4C
/* 042 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 043 [def:0001] [use:0001] */          //trace_PC(0x7AFA);
/* 044 [def:0001] [use:0001] */      case 0x7AFC: L_7afc: //4C 55 7A
/* 045 [def:0001] [use:0001] */          //trace_PC(0x7AFC);
/* 046 [def:0001] [use:0001] */          PC = 0x7a55;
/*                           */          clockticks += 45; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7AFF: L_7aff: //A5 78 29
/* 001 [def:0009] [use:0001] */          A=ram[0x0078];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7AFF);
/* 004 [def:0001] [use:0001] */      case 0x7B01: L_7b01: //29 0C D0
/* 005 [def:0009] [use:0008] */          A &= 0x0C;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7B01);
/* 008 [def:0001] [use:0001] */      case 0x7B03: L_7b03: //D0 21 A5
/* 009 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 010 [def:0001] [use:0001] */          {
/* 011 [def:0001] [use:0001] */              //trace_PC(0x7B03);
/* 012 [def:0001] [use:0001] */              PC = 0x7b26;
/*                           */              clockticks += 9;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B03);
/* 002 [def:0001] [use:0001] */      case 0x7B05: L_7b05: //A5 CD F0
/* 003 [def:0009] [use:0001] */          A=ram[0x00CD];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B05);
/* 006 [def:0001] [use:0001] */      case 0x7B07: L_7b07: //F0 1A 10
/* 007 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7B07);
/* 010 [def:0001] [use:0001] */              PC = 0x7b23;
/*                           */              clockticks += 14;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B07);
/* 002 [def:0001] [use:0001] */      case 0x7B09: L_7b09: //10 1C A6
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x7B09);
/* 006 [def:0001] [use:0001] */              PC = 0x7b27;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B09);
/* 002 [def:0001] [use:0001] */      case 0x7B0B: L_7b0b: //A6 CB A9
/* 003 [def:0001] [use:0001] */          X=ram[0x00CB];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B0B);
/* 006 [def:0001] [use:0001] */      case 0x7B0D: L_7b0d: //A9 06 8D
/* 007 [def:0009] [use:0000] */          A=0x06;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7B0D);
/* 010 [def:0001] [use:0001] */      case 0x7B0F: L_7b0f: //8D 00 3A
/* 011 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7B0F);
/* 013 [def:0001] [use:0001] */      case 0x7B12: L_7b12: //9D 00 32
/* 014 [def:0001] [use:0019] */          ram[0x3200 + X /* can't wrap */] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7B12);
/* 016 [def:0001] [use:0001] */      case 0x7B15: L_7b15: //A9 0E C6
/* 017 [def:0009] [use:0000] */          A=0x0E;
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7B15);
/* 020 [def:0001] [use:0001] */      case 0x7B17: L_7b17: //C6 CB C6
/* 021 [def:0001] [use:0001] */          ZN=ram[0x00CB]-1;
/* 022 [def:0001] [use:0001] */          ram[0x00CB] = ZN;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7B17);
/* 024 [def:0001] [use:0001] */      case 0x7B19: L_7b19: //C6 CC D0
/* 025 [def:0001] [use:0001] */          ZN=ram[0x00CC]-1;
/* 026 [def:0001] [use:0001] */          ram[0x00CC] = ZN;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7B19);
/* 028 [def:0001] [use:0001] */      case 0x7B1B: L_7b1b: //D0 06 A2
/* 029 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 030 [def:0001] [use:0001] */          {
/* 031 [def:0001] [use:0001] */              //trace_PC(0x7B1B);
/* 032 [def:0001] [use:0001] */              PC = 0x7b23;
/*                           */              clockticks += 46;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B1B);
/* 002 [def:0001] [use:0001] */      case 0x7B1D: L_7b1d: //A2 40 86
/* 003 [def:0001] [use:0001] */          X=0x40;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B1D);
/* 006 [def:0001] [use:0001] */      case 0x7B1F: L_7b1f: //86 CD E6
/* 007 [def:0001] [use:0001] */          ram[0x00CD] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7B1F);
/* 009 [def:0001] [use:0001] */      case 0x7B21: L_7b21: //E6 CB 8D
/* 010 [def:1801] [use:0001] */          ZN=++ram[0x00CB];
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7B21);
/* 012 [def:0001] [use:0001] */      case 0x7B23: L_7b23: //8D 00 3A
/* 013 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7B23);
/* 015 [def:0001] [use:0001] */      case 0x7B26: L_7b26: //60 A4 CC
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7B26);
/* 017 [def:0001] [use:0001] */          PC=stack[++S];
/* 018 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 019 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 65; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7B27: L_7b27: //A4 CC D0
/* 001 [def:0021] [use:0001] */          Y=ram[0x00CC];
/* 002 [def:1801] [use:0020] */          ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7B27);
/* 004 [def:0001] [use:0001] */      case 0x7B29: L_7b29: //D0 02 84
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7B29);
/* 008 [def:0001] [use:0001] */              PC = 0x7b2d;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B29);
/* 002 [def:0001] [use:0001] */      case 0x7B2B: L_7b2b: //84 CF 0A
/* 003 [def:0001] [use:0020] */          ram[0x00CF] = Y;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7B2B);
/* 005 [def:0001] [use:0001] */      case 0x7B2D: L_7b2d: //0A 10 35
/* 006 [def:2001] [use:0008] */          C = A & 0x80;
/* 007 [def:0009] [use:0008] */          A = A << 1;
/* 008 [def:1801] [use:0008] */          ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7B2D);
/* 010 [def:0001] [use:0001] */      case 0x7B2E: L_7b2e: //10 35 B9
/* 011 [def:0001] [use:1001] */          if (ZN < 0)
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x7B2E);
/* 014 [def:0001] [use:0001] */              PC = 0x7b65;
/*                           */              clockticks += 12;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B2E);
/* 002 [def:0001] [use:0001] */      case 0x7B30: L_7b30: //B9 C0 7B
/* 003 [def:0009] [use:0021] */          A=ram[0x7BC0 + Y /* can't wrap */];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B30);
/* 006 [def:0001] [use:0001] */      case 0x7B33: L_7b33: //10 0C 85
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7B33);
/* 010 [def:0001] [use:0001] */              PC = 0x7b41;
/*                           */              clockticks += 18;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B33);
/* 002 [def:0001] [use:0001] */      case 0x7B35: L_7b35: //85 CC E6
/* 003 [def:0001] [use:0008] */          ram[0x00CC] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7B35);
/* 005 [def:0001] [use:0001] */      case 0x7B37: L_7b37: //E6 CE E6
/* 006 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7B37);
/* 008 [def:0001] [use:0001] */      case 0x7B39: L_7b39: //E6 CE E6
/* 009 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7B39);
/* 011 [def:0001] [use:0001] */      case 0x7B3B: L_7b3b: //E6 CE A5
/* 012 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7B3B);
/* 014 [def:0001] [use:0001] */      case 0x7B3D: L_7b3d: //A5 CF 90
/* 015 [def:0009] [use:0001] */          A=ram[0x00CF];
/* 016 [def:1801] [use:0008] */          ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7B3D);
/* 018 [def:0001] [use:0001] */      case 0x7B3F: L_7b3f: //90 0B 65
/* 019 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 020 [def:0001] [use:0001] */          {
/* 021 [def:0001] [use:0001] */              //trace_PC(0x7B3F);
/* 022 [def:0001] [use:0001] */              PC = 0x7b4c;
/*                           */              clockticks += 40;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B3F);
/* 002 [def:0001] [use:0001] */      case 0x7B41: L_7b41: //65 CE AA
/* 003 [def:b801] [use:6001] */          ADC(ram[0x00CE]);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7B41);
/* 005 [def:0001] [use:0001] */      case 0x7B43: L_7b43: //AA B5 23
/* 006 [def:0011] [use:0008] */          X=A;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7B43);
/* 009 [def:0001] [use:0001] */      case 0x7B44: L_7b44: //B5 23 65
/* 010 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x23 + X)];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7B44);
/* 013 [def:0001] [use:0001] */      case 0x7B46: L_7b46: //65 CF 85
/* 014 [def:b801] [use:6001] */          ADC(ram[0x00CF]);
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7B46);
/* 016 [def:0001] [use:0001] */      case 0x7B48: L_7b48: //85 CF B5
/* 017 [def:0001] [use:0008] */          ram[0x00CF] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7B48);
/* 019 [def:0001] [use:0001] */      case 0x7B4A: L_7b4a: //B5 23 E6
/* 020 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x23 + X)];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7B4A);
/* 023 [def:0001] [use:0001] */      case 0x7B4C: L_7b4c: //E6 CC A6
/* 024 [def:1801] [use:0001] */          ZN=++ram[0x00CC];
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7B4C);
/* 026 [def:0001] [use:0001] */      case 0x7B4E: L_7b4e: //A6 CB 9D
/* 027 [def:0001] [use:0001] */          X=ram[0x00CB];
/* 028 [def:1800] [use:0010] */  //      ZN = X;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7B4E);
/* 030 [def:0001] [use:0001] */      case 0x7B50: L_7b50: //9D 00 32
/* 031 [def:0001] [use:0019] */          ram[0x3200 + X /* can't wrap */] = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7B50);
/* 033 [def:0001] [use:0001] */      case 0x7B53: L_7b53: //A9 04 8D
/* 034 [def:0009] [use:0000] */          A=0x04;
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7B53);
/* 037 [def:0001] [use:0001] */      case 0x7B55: L_7b55: //8D 00 3A
/* 038 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x7B55);
/* 040 [def:0001] [use:0001] */      case 0x7B58: L_7b58: //A9 0C E8
/* 041 [def:0009] [use:0000] */          A=0x0C;
/* 042 [def:1800] [use:0008] */  //      ZN = A;
/* 043 [def:0001] [use:0001] */          //trace_PC(0x7B58);
/* 044 [def:0001] [use:0001] */      case 0x7B5A: L_7b5a: //E8 E0 15
/* 045 [def:0011] [use:0010] */          X++;
/* 046 [def:1800] [use:0010] */  //      ZN = X;
/* 047 [def:0001] [use:0001] */          //trace_PC(0x7B5A);
/* 048 [def:0001] [use:0001] */      case 0x7B5B: L_7b5b: //E0 15 90
/* 049 [def:0101] [use:0000] */          ZN=0x15;
/* 050 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 051 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 052 [def:0001] [use:0001] */          //trace_PC(0x7B5B);
/* 053 [def:0001] [use:0001] */      case 0x7B5D: L_7b5d: //90 C2 A2
/* 054 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 055 [def:0001] [use:0001] */          {
/* 056 [def:0001] [use:0001] */              //trace_PC(0x7B5D);
/* 057 [def:0001] [use:0001] */              PC = 0x7b21;
/*                           */              clockticks += 88;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B5D);
/* 002 [def:0001] [use:0001] */      case 0x7B5F: L_7b5f: //A2 00 86
/* 003 [def:0001] [use:0001] */          X=0x00;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B5F);
/* 006 [def:0001] [use:0001] */      case 0x7B61: L_7b61: //86 CD F0
/* 007 [def:0001] [use:0001] */          ram[0x00CD] = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7B61);
/* 009 [def:0001] [use:0001] */      case 0x7B63: L_7b63: //F0 BE A6
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7B63);
/* 013 [def:0001] [use:0001] */              PC = 0x7b23;
/*                           */              clockticks += 95;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B63);
/* 002 [def:0001] [use:0001] */      case 0x7B65: L_7b65: //A6 CB A9
/* 003 [def:0001] [use:0001] */          X=ram[0x00CB];
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B65);
/* 006 [def:0001] [use:0001] */      case 0x7B67: L_7b67: //A9 08 9D
/* 007 [def:0009] [use:0000] */          A=0x08;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7B67);
/* 010 [def:0001] [use:0001] */      case 0x7B69: L_7b69: //9D 00 32
/* 011 [def:0001] [use:0019] */          ram[0x3200 + X /* can't wrap */] = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7B69);
/* 013 [def:0001] [use:0001] */      case 0x7B6C: L_7b6c: //8D 00 3A
/* 014 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7B6C);
/* 016 [def:0001] [use:0001] */      case 0x7B6F: L_7b6f: //A9 09 8D
/* 017 [def:0009] [use:0000] */          A=0x09;
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7B6F);
/* 020 [def:0001] [use:0001] */      case 0x7B71: L_7b71: //8D 00 3A
/* 021 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7B71);
/* 023 [def:0001] [use:0001] */      case 0x7B74: L_7b74: //A9 08 8D
/* 024 [def:0009] [use:0000] */          A=0x08;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7B74);
/* 027 [def:0001] [use:0001] */      case 0x7B76: L_7b76: //8D 00 3A
/* 028 [def:0001] [use:0008] */          ram[0x3A00] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7B76);
/* 030 [def:0001] [use:0001] */      case 0x7B79: L_7b79: //A2 00 B9
/* 031 [def:0001] [use:0001] */          X=0x00;
/* 032 [def:1800] [use:0010] */  //      ZN = X;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x7B79);
/* 034 [def:0001] [use:0001] */      case 0x7B7B: L_7b7b: //B9 C0 7B
/* 035 [def:0009] [use:0021] */          A=ram[0x7BC0 + Y /* can't wrap */];
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x7B7B);
/* 038 [def:0001] [use:0001] */      case 0x7B7E: L_7b7e: //10 2A 86
/* 039 [def:0001] [use:1001] */          if (ZN < 0)
/* 040 [def:0001] [use:0001] */          {
/* 041 [def:0001] [use:0001] */              //trace_PC(0x7B7E);
/* 042 [def:0001] [use:0001] */              PC = 0x7baa;
/*                           */              clockticks += 133;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B7E);
/* 002 [def:0001] [use:0001] */      case 0x7B80: L_7b80: //86 CC AD
/* 003 [def:0001] [use:0001] */          ram[0x00CC] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7B80);
/* 005 [def:0001] [use:0001] */      case 0x7B82: L_7b82: //AD 40 2C
/* 006 [def:0009] [use:0001] */          A=ram[0x2C40];
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7B82);
/* 009 [def:0001] [use:0001] */      case 0x7B85: L_7b85: //8E 00 3A
/* 010 [def:0001] [use:0001] */          ram[0x3A00] = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7B85);
/* 012 [def:0001] [use:0001] */      case 0x7B88: L_7b88: //45 CF F0
/* 013 [def:0001] [use:0001] */          A^=ram[0x00CF];
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7B88);
/* 016 [def:0001] [use:0001] */      case 0x7B8A: L_7b8a: //F0 16 A0
/* 017 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x7B8A);
/* 020 [def:0001] [use:0001] */              PC = 0x7ba2;
/*                           */              clockticks += 148;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7B8A);
/* 002 [def:0001] [use:0001] */      case 0x7B9E: L_7b9e: //A6 CB 10
/* 003 [def:0001] [use:0001] */          X=ram[0x00CB];
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7B9E);
/* 006 [def:0001] [use:0001] */      case 0x7BA0: L_7ba0: //10 B8 E6
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7BA0);
/* 010 [def:0001] [use:0001] */              PC = 0x7b5a;
/*                           */              clockticks += 153;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BA0);
/* 002 [def:0001] [use:0001] */      case 0x7BA2: L_7ba2: //E6 CE E6
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7BA2);
/* 005 [def:0001] [use:0001] */      case 0x7BA4: L_7ba4: //E6 CE E6
/* 006 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7BA4);
/* 008 [def:0001] [use:0001] */      case 0x7BA6: L_7ba6: //E6 CE 10
/* 009 [def:1801] [use:0001] */          ZN=++ram[0x00CE];
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7BA6);
/* 011 [def:0001] [use:0001] */      case 0x7BA8: L_7ba8: //10 F4 65
/* 012 [def:0001] [use:1001] */          if (ZN < 0)
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7BA8);
/* 015 [def:0001] [use:0001] */              PC = 0x7b9e;
/*                           */              clockticks += 170;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BA8);
/* 002 [def:0001] [use:0001] */      case 0x7BAA: L_7baa: //65 CE A8
/* 003 [def:b801] [use:6001] */          ADC(ram[0x00CE]);
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7BAA);
/* 005 [def:0001] [use:0001] */      case 0x7BAC: L_7bac: //A8 AD 40
/* 006 [def:0021] [use:0008] */          Y=A;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7BAC);
/* 009 [def:0001] [use:0001] */      case 0x7BAD: L_7bad: //AD 40 2C
/* 010 [def:0009] [use:0001] */          A=ram[0x2C40];
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7BAD);
/* 013 [def:0001] [use:0001] */      case 0x7BB0: L_7bb0: //8E 00 3A
/* 014 [def:0001] [use:0001] */          ram[0x3A00] = X;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7BB0);
/* 016 [def:0001] [use:0001] */      case 0x7BB3: L_7bb3: //99 23 00
/* 017 [def:0001] [use:0021] */          ram[(unsigned short)(0x0023 + Y)] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7BB3);
/* 019 [def:0001] [use:0001] */      case 0x7BB6: L_7bb6: //65 CF 85
/* 020 [def:b801] [use:6001] */          ADC(ram[0x00CF]);
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7BB6);
/* 022 [def:0001] [use:0001] */      case 0x7BB8: L_7bb8: //85 CF E6
/* 023 [def:0001] [use:0008] */          ram[0x00CF] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7BB8);
/* 025 [def:0001] [use:0001] */      case 0x7BBA: L_7bba: //E6 CC A9
/* 026 [def:1801] [use:0001] */          ZN=++ram[0x00CC];
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7BBA);
/* 028 [def:0001] [use:0001] */      case 0x7BBC: L_7bbc: //A9 00 F0
/* 029 [def:0009] [use:0000] */          A=0x00;
/* 030 [def:1801] [use:0008] */          ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x7BBC);
/* 032 [def:0001] [use:0001] */      case 0x7BBE: L_7bbe: //F0 DE 00
/* 033 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 034 [def:0001] [use:0001] */          {
/* 035 [def:0001] [use:0001] */              //trace_PC(0x7BBE);
/* 036 [def:0001] [use:0001] */              PC = 0x7b9e;
/*                           */              clockticks += 203;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BBE);
/* 002 [def:0001] [use:0001] */      case 0x7BC7: L_7bc7: //A4 CD D0
/* 003 [def:0021] [use:0001] */          Y=ram[0x00CD];
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7BC7);
/* 006 [def:0001] [use:0001] */      case 0x7BC9: L_7bc9: //D0 17 A9
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7BC9);
/* 010 [def:0001] [use:0001] */              PC = 0x7be2;
/*                           */              clockticks += 208;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BC9);
/* 002 [def:0001] [use:0001] */      case 0x7BCB: L_7bcb: //A9 08 C5
/* 003 [def:0009] [use:0000] */          A=0x08;
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7BCB);
/* 006 [def:0001] [use:0001] */      case 0x7BCD: L_7bcd: //C5 CE 90
/* 007 [def:0001] [use:0001] */          ZN=ram[0x00CE];
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:0001] [use:0001] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7BCD);
/* 011 [def:0001] [use:0001] */      case 0x7BCF: L_7bcf: //90 11 66
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7BCF);
/* 015 [def:0001] [use:0001] */              PC = 0x7be2;
/*                           */              clockticks += 216;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BCF);
/* 002 [def:0001] [use:0001] */      case 0x7BD1: L_7bd1: //66 CD A5
/* 003 [def:10001] [use:2000] */          saveflags = (C != 0 ? 1 : 0);
/* 004 [def:0101] [use:0001] */          ZN=ram[0x00CD];
/* 005 [def:2001] [use:0100] */          C = ZN & 0x01;
/* 006 [def:0101] [use:0100] */          ZN = ZN >> 1;
/* 007 [def:0101] [use:10100] */          if (saveflags) ZN |= 0x80;
/* 008 [def:0001] [use:0100] */          ram[0x00CD] = ZN;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7BD1);
/* 010 [def:0001] [use:0001] */      case 0x7BD3: L_7bd3: //A5 D0 F0
/* 011 [def:0009] [use:0001] */          A=ram[0x00D0];
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7BD3);
/* 014 [def:0001] [use:0001] */      case 0x7BD5: L_7bd5: //F0 0B A2
/* 015 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7BD5);
/* 018 [def:0001] [use:0001] */              PC = 0x7be2;
/*                           */              clockticks += 226;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BD5);
/* 002 [def:0001] [use:0001] */      case 0x7BE2: L_7be2: //60 2C 02
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7BE2);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 231; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7BE3: L_7be3: //2C 02 20
/* 001 [def:1101] [use:0001] */          ZN=ram[0x2002];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 002 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 003 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7BE3);
/* 005 [def:0001] [use:0001] */      case 0x7BE6: L_7be6: //30 FB 20
/* 006 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 007 [def:0001] [use:0001] */          {
/* 008 [def:0001] [use:0001] */              //trace_PC(0x7BE6);
/* 009 [def:0001] [use:0001] */              PC = 0x7be3;
/*                           */              clockticks += 7;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BE6);
/* 002 [def:0001] [use:0001] */      case 0x7BE8: L_7be8: //20 18 71
/* 003 [def:0001] [use:0001] */          stack[S--] = 0x7B;
/* 004 [def:0001] [use:0001] */          stack[S--] = 0xEA;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7BE8);
/* 006 [def:0001] [use:0001] */          PC = 0x7118;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7BEB: L_7beb: //A9 B0 8D
/* 001 [def:0009] [use:0000] */          A=0xB0;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7BEB);
/* 004 [def:0001] [use:0001] */      case 0x7BED: L_7bed: //8D 03 40
/* 005 [def:0001] [use:0008] */          ram[0x4003] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7BED);
/* 007 [def:0001] [use:0001] */      case 0x7BF0: L_7bf0: //A9 00 A2
/* 008 [def:0009] [use:0000] */          A=0x00;
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7BF0);
/* 011 [def:0001] [use:0001] */      case 0x7BF2: L_7bf2: //A2 03 95
/* 012 [def:0001] [use:0001] */          X=0x03;
/* 013 [def:1800] [use:0010] */  //      ZN = X;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7BF2);
/* 015 [def:0001] [use:0001] */      case 0x7BF4: L_7bf4: //95 61 95
/* 016 [def:0001] [use:0019] */          ram[(unsigned char)(0x61 + X)] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7BF4);
/* 018 [def:0001] [use:0001] */      case 0x7BF6: L_7bf6: //95 64 CA
/* 019 [def:0001] [use:0019] */          ram[(unsigned char)(0x64 + X)] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7BF6);
/* 021 [def:0001] [use:0001] */      case 0x7BF8: L_7bf8: //CA D0 F9
/* 022 [def:0011] [use:0010] */          X--;
/* 023 [def:1801] [use:0010] */          ZN = X;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7BF8);
/* 025 [def:0001] [use:0001] */      case 0x7BF9: L_7bf9: //D0 F9 9D
/* 026 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x7BF9);
/* 029 [def:0001] [use:0001] */              PC = 0x7bf4;
/*                           */              clockticks += 26;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BF9);
/* 002 [def:0001] [use:0001] */      case 0x7BFB: L_7bfb: //9D 00 02
/* 003 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7BFB);
/* 005 [def:0001] [use:0001] */      case 0x7BFE: L_7bfe: //E8 D0 FA
/* 006 [def:0011] [use:0010] */          X++;
/* 007 [def:1801] [use:0010] */          ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7BFE);
/* 009 [def:0001] [use:0001] */      case 0x7BFF: L_7bff: //D0 FA 85
/* 010 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7BFF);
/* 013 [def:0001] [use:0001] */              PC = 0x7bfb;
/*                           */              clockticks += 35;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7BFF);
/* 002 [def:0001] [use:0001] */      case 0x7C01: L_7c01: //85 DD 85
/* 003 [def:0001] [use:0008] */          ram[0x00DD] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7C01);
/* 005 [def:0001] [use:0001] */      case 0x7C03: L_7c03: //85 D3 85
/* 006 [def:0001] [use:0008] */          ram[0x00D3] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7C03);
/* 008 [def:0001] [use:0001] */      case 0x7C05: L_7c05: //85 FA 85
/* 009 [def:0001] [use:0008] */          ram[0x00FA] = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7C05);
/* 011 [def:0001] [use:0001] */      case 0x7C07: L_7c07: //85 FC AD
/* 012 [def:0001] [use:0008] */          ram[0x00FC] = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7C07);
/* 014 [def:0001] [use:0001] */      case 0x7C09: L_7c09: //AD 01 28
/* 015 [def:0009] [use:0001] */          A=ram[0x2801];
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7C09);
/* 018 [def:0001] [use:0001] */      case 0x7C0C: L_7c0c: //29 02 85
/* 019 [def:0009] [use:0008] */          A &= 0x02;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7C0C);
/* 022 [def:0001] [use:0001] */      case 0x7C0E: L_7c0e: //85 FB 85
/* 023 [def:0001] [use:0008] */          ram[0x00FB] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7C0E);
/* 025 [def:0001] [use:0001] */      case 0x7C10: L_7c10: //85 FD A9
/* 026 [def:0001] [use:0008] */          ram[0x00FD] = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7C10);
/* 028 [def:0001] [use:0001] */      case 0x7C12: L_7c12: //A9 01 20
/* 029 [def:0009] [use:0000] */          A=0x01;
/* 030 [def:1801] [use:0008] */          ZN = A;
/* 031 [def:0001] [use:0001] */          //trace_PC(0x7C12);
/* 032 [def:0001] [use:0001] */      case 0x7C14: L_7c14: //20 00 63
/* 033 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 034 [def:0001] [use:0001] */          stack[S--] = 0x16;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x7C14);
/* 036 [def:0001] [use:0001] */          PC = 0x6300;
/*                           */          clockticks += 62; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C17: L_7c17: //A9 98 8D
/* 001 [def:0009] [use:0000] */          A=0x98;
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C17);
/* 004 [def:0001] [use:0001] */      case 0x7C19: L_7c19: //8D E9 02
/* 005 [def:0001] [use:0008] */          ram[0x02E9] = A;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7C19);
/* 007 [def:0001] [use:0001] */      case 0x7C1C: L_7c1c: //8D E8 02
/* 008 [def:0001] [use:0008] */          ram[0x02E8] = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7C1C);
/* 010 [def:0001] [use:0001] */      case 0x7C1F: L_7c1f: //A9 7F 8D
/* 011 [def:0009] [use:0000] */          A=0x7F;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7C1F);
/* 014 [def:0001] [use:0001] */      case 0x7C21: L_7c21: //8D EC 02
/* 015 [def:0001] [use:0008] */          ram[0x02EC] = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7C21);
/* 017 [def:0001] [use:0001] */      case 0x7C24: L_7c24: //A9 06 8D
/* 018 [def:0009] [use:0000] */          A=0x06;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7C24);
/* 021 [def:0001] [use:0001] */      case 0x7C26: L_7c26: //8D EE 02
/* 022 [def:0001] [use:0008] */          ram[0x02EE] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7C26);
/* 024 [def:0001] [use:0001] */      case 0x7C29: L_7c29: //A9 FF 85
/* 025 [def:0009] [use:0000] */          A=0xFF;
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7C29);
/* 028 [def:0001] [use:0001] */      case 0x7C2B: L_7c2b: //85 42 85
/* 029 [def:0001] [use:0008] */          ram[0x0042] = A;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x7C2B);
/* 031 [def:0001] [use:0001] */      case 0x7C2D: L_7c2d: //85 43 A9
/* 032 [def:0001] [use:0008] */          ram[0x0043] = A;
/* 033 [def:0001] [use:0001] */          //trace_PC(0x7C2D);
/* 034 [def:0001] [use:0001] */      case 0x7C2F: L_7c2f: //A9 30 8D
/* 035 [def:0009] [use:0000] */          A=0x30;
/* 036 [def:1801] [use:0008] */          ZN = A;
/* 037 [def:0001] [use:0001] */          //trace_PC(0x7C2F);
/* 038 [def:0001] [use:0001] */      case 0x7C31: L_7c31: //8D ED 02
/* 039 [def:0001] [use:0008] */          ram[0x02ED] = A;
/* 040 [def:0001] [use:0001] */          //trace_PC(0x7C31);
/* 041 [def:0001] [use:0001] */      case 0x7C34: L_7c34: //20 CF 7F
/* 042 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 043 [def:0001] [use:0001] */          stack[S--] = 0x36;
/* 044 [def:0001] [use:0001] */          //trace_PC(0x7C34);
/* 045 [def:0001] [use:0001] */          PC = 0x7fcf;
/*                           */          clockticks += 45; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C37: L_7c37: //AD 00 28
/* 001 [def:0009] [use:0001] */          A=ram[0x2800];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C37);
/* 004 [def:0001] [use:0001] */      case 0x7C3A: L_7c3a: //29 03 A8
/* 005 [def:0009] [use:0008] */          A &= 0x03;
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7C3A);
/* 008 [def:0001] [use:0001] */      case 0x7C3C: L_7c3c: //A8 B9 6B
/* 009 [def:0021] [use:0008] */          Y=A;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7C3C);
/* 012 [def:0001] [use:0001] */      case 0x7C3D: L_7c3d: //B9 6B 7C
/* 013 [def:0009] [use:0021] */          A=ram[0x7C6B + Y /* can't wrap */];
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7C3D);
/* 016 [def:0001] [use:0001] */      case 0x7C40: L_7c40: //85 F8 85
/* 017 [def:0001] [use:0008] */          ram[0x00F8] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7C40);
/* 019 [def:0001] [use:0001] */      case 0x7C42: L_7c42: //85 69 85
/* 020 [def:0001] [use:0008] */          ram[0x0069] = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7C42);
/* 022 [def:0001] [use:0001] */      case 0x7C44: L_7c44: //85 6C 30
/* 023 [def:0001] [use:0008] */          ram[0x006C] = A;
/* 024 [def:0001] [use:0001] */          //trace_PC(0x7C44);
/* 025 [def:0001] [use:0001] */      case 0x7C46: L_7c46: //30 02 A9
/* 026 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 027 [def:0001] [use:0001] */          {
/* 028 [def:0001] [use:0001] */              //trace_PC(0x7C46);
/* 029 [def:0001] [use:0001] */              PC = 0x7c4a;
/*                           */              clockticks += 22;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C46);
/* 002 [def:0001] [use:0001] */      case 0x7C48: L_7c48: //A9 01 85
/* 003 [def:0009] [use:0000] */          A=0x01;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7C48);
/* 006 [def:0001] [use:0001] */      case 0x7C4A: L_7c4a: //85 6A 85
/* 007 [def:0001] [use:0008] */          ram[0x006A] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7C4A);
/* 009 [def:0001] [use:0001] */      case 0x7C4C: L_7c4c: //85 F9 85
/* 010 [def:0001] [use:0008] */          ram[0x00F9] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7C4C);
/* 012 [def:0001] [use:0001] */      case 0x7C4E: L_7c4e: //85 6D A9
/* 013 [def:0001] [use:0008] */          ram[0x006D] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7C4E);
/* 015 [def:0001] [use:0001] */      case 0x7C50: L_7c50: //A9 03 2D
/* 016 [def:0009] [use:0000] */          A=0x03;
/* 017 [def:1800] [use:0008] */  //      ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7C50);
/* 019 [def:0001] [use:0001] */      case 0x7C52: L_7c52: //2D 02 28
/* 020 [def:0009] [use:0009] */          A &= ram[0x2802];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7C52);
/* 023 [def:0001] [use:0001] */      case 0x7C55: L_7c55: //AA E8 E8
/* 024 [def:0011] [use:0008] */          X=A;
/* 025 [def:1800] [use:0008] */  //      ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7C55);
/* 027 [def:0001] [use:0001] */      case 0x7C56: L_7c56: //E8 E8 C0
/* 028 [def:0011] [use:0010] */          X++;
/* 029 [def:1800] [use:0010] */  //      ZN = X;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x7C56);
/* 031 [def:0001] [use:0001] */      case 0x7C57: L_7c57: //E8 C0 03
/* 032 [def:0011] [use:0010] */          X++;
/* 033 [def:1800] [use:0010] */  //      ZN = X;
/* 034 [def:0001] [use:0001] */          //trace_PC(0x7C57);
/* 035 [def:0001] [use:0001] */      case 0x7C58: L_7c58: //C0 03 D0
/* 036 [def:0101] [use:0001] */          ZN=0x03;
/* 037 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 038 [def:1801] [use:0120] */          ZN=/*+0x100*/Y-ZN;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x7C58);
/* 040 [def:0001] [use:0001] */      case 0x7C5A: L_7c5a: //D0 01 E8
/* 041 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 042 [def:0001] [use:0001] */          {
/* 043 [def:0001] [use:0001] */              //trace_PC(0x7C5A);
/* 044 [def:0001] [use:0001] */              PC = 0x7c5d;
/*                           */              clockticks += 49;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C5A);
/* 002 [def:0001] [use:0001] */      case 0x7C5D: L_7c5d: //A5 8D 29
/* 003 [def:0009] [use:0001] */          A=ram[0x008D];
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7C5D);
/* 006 [def:0001] [use:0001] */      case 0x7C5F: L_7c5f: //29 03 C9
/* 007 [def:0009] [use:0008] */          A &= 0x03;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7C5F);
/* 010 [def:0001] [use:0001] */      case 0x7C61: L_7c61: //C9 03 D0
/* 011 [def:0101] [use:0000] */          ZN=0x03;
/* 012 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 013 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7C61);
/* 015 [def:0001] [use:0001] */      case 0x7C63: L_7c63: //D0 01 E8
/* 016 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 017 [def:0001] [use:0001] */          {
/* 018 [def:0001] [use:0001] */              //trace_PC(0x7C63);
/* 019 [def:0001] [use:0001] */              PC = 0x7c66;
/*                           */              clockticks += 60;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C63);
/* 002 [def:0001] [use:0001] */      case 0x7C66: L_7c66: //86 6E 4C
/* 003 [def:0001] [use:0001] */          ram[0x006E] = X;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7C66);
/* 005 [def:0001] [use:0001] */      case 0x7C68: L_7c68: //4C 44 78
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7C68);
/* 007 [def:0001] [use:0001] */          PC = 0x7844;
/*                           */          clockticks += 64; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C6F: L_7c6f: //A2 D5 84
/* 001 [def:0001] [use:0001] */          X=0xD5;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C6F);
/* 004 [def:0001] [use:0001] */      case 0x7C71: L_7c71: //84 09 A0
/* 005 [def:0001] [use:0020] */          ram[0x0009] = Y;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7C71);
/* 007 [def:0001] [use:0001] */      case 0x7C73: L_7c73: //A0 E0 84
/* 008 [def:0021] [use:0000] */          Y=0xE0;
/* 009 [def:1801] [use:0020] */          ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7C73);
/* 011 [def:0001] [use:0001] */      case 0x7C75: L_7c75: //84 01 20
/* 012 [def:0001] [use:0020] */          ram[0x0001] = Y;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7C75);
/* 014 [def:0001] [use:0001] */      case 0x7C77: L_7c77: //20 1F 7A
/* 015 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 016 [def:0001] [use:0001] */          stack[S--] = 0x79;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7C77);
/* 018 [def:0001] [use:0001] */          PC = 0x7a1f;
/*                           */          clockticks += 16; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C7A: L_7c7a: //A9 70 20
/* 001 [def:0009] [use:0000] */          A=0x70;
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C7A);
/* 004 [def:0001] [use:0001] */      case 0x7C7C: L_7c7c: //20 EA 7A
/* 005 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 006 [def:0001] [use:0001] */          stack[S--] = 0x7E;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7C7C);
/* 008 [def:0001] [use:0001] */          PC = 0x7aea;
/*                           */          clockticks += 9; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C7F: L_7c7f: //4C 89 7C
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C7F);
/* 002 [def:0001] [use:0001] */          PC = 0x7c89;
/*                           */          clockticks += 3; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C82: L_7c82: //A2 CA A9
/* 001 [def:0001] [use:0001] */          X=0xCA;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C82);
/* 004 [def:0001] [use:0001] */      case 0x7C84: L_7c84: //A9 A4 20
/* 005 [def:0009] [use:0000] */          A=0xA4;
/* 006 [def:1801] [use:0008] */          ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7C84);
/* 008 [def:0001] [use:0001] */      case 0x7C86: L_7c86: //20 D5 7C
/* 009 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 010 [def:0001] [use:0001] */          stack[S--] = 0x88;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7C86);
/* 012 [def:0001] [use:0001] */          PC = 0x7cd5;
/*                           */          clockticks += 12; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C89: L_7c89: //C6 09 F0
/* 001 [def:0001] [use:0001] */          ZN=ram[0x0009]-1;
/* 002 [def:0001] [use:0001] */          ram[0x0009] = ZN;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C89);
/* 004 [def:0001] [use:0001] */      case 0x7C8B: L_7c8b: //F0 02 10
/* 005 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7C8B);
/* 008 [def:0001] [use:0001] */              PC = 0x7c8f;
/*                           */              clockticks += 8;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C8B);
/* 002 [def:0001] [use:0001] */      case 0x7C8D: L_7c8d: //10 F3 60
/* 003 [def:0001] [use:1001] */          if (ZN < 0)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x7C8D);
/* 006 [def:0001] [use:0001] */              PC = 0x7c82;
/*                           */              clockticks += 10;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7C8D);
/* 002 [def:0001] [use:0001] */      case 0x7C8F: L_7c8f: //60 A9 F7
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7C8F);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 15; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7C95: L_7c95: //08 86 1D
/* 001 [def:0081] [use:f881] */          stack[S--] = P; // todo: consolidate ZN, C
/* 002 [def:0001] [use:0001] */          //trace_PC(0x7C95);
/* 003 [def:0001] [use:0001] */      case 0x7C96: L_7c96: //86 1D 88
/* 004 [def:0001] [use:0001] */          ram[0x001D] = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7C96);
/* 006 [def:0001] [use:0001] */      case 0x7C98: L_7c98: //88 84 1C
/* 007 [def:0021] [use:0020] */          Y--;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7C98);
/* 010 [def:0001] [use:0001] */      case 0x7C99: L_7c99: //84 1C 18
/* 011 [def:0001] [use:0020] */          ram[0x001C] = Y;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7C99);
/* 013 [def:0001] [use:0001] */      case 0x7C9B: L_7c9b: //18 65 1C
/* 014 [def:2001] [use:0000] */          C = 0;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7C9B);
/* 016 [def:0001] [use:0001] */      case 0x7C9C: L_7c9c: //65 1C 85
/* 017 [def:b801] [use:6001] */          ADC(ram[0x001C]);
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7C9C);
/* 019 [def:0001] [use:0001] */      case 0x7C9E: L_7c9e: //85 1B 28
/* 020 [def:0001] [use:0008] */          ram[0x001B] = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7C9E);
/* 022 [def:0001] [use:0001] */      case 0x7CA0: L_7ca0: //28 AA 08
/* 023 [def:f881] [use:0081] */          P=stack[++S]; // todo: set C, ZN
/* 024 [def:f801] [use:f800] */          P |= 0x20; /* PLP - needs work */
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7CA0);
/* 026 [def:0001] [use:0001] */      case 0x7CA1: L_7ca1: //AA 08 B5
/* 027 [def:0011] [use:0008] */          X=A;
/* 028 [def:1801] [use:0008] */          ZN = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7CA1);
/* 030 [def:0001] [use:0001] */      case 0x7CA2: L_7ca2: //08 B5 00
/* 031 [def:0081] [use:f881] */          stack[S--] = P; // todo: consolidate ZN, C
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7CA2);
/* 033 [def:0001] [use:0001] */      case 0x7CA3: L_7ca3: //B5 00 4A
/* 034 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x00 + X)];
/* 035 [def:1800] [use:0008] */  //      ZN = A;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7CA3);
/* 037 [def:0001] [use:0001] */      case 0x7CA5: L_7ca5: //4A 4A 4A
/* 038 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 039 [def:0009] [use:0008] */          A = A >> 1;
/* 040 [def:1800] [use:0008] */  //      ZN = A;
/* 041 [def:0001] [use:0001] */          //trace_PC(0x7CA5);
/* 042 [def:0001] [use:0001] */      case 0x7CA6: L_7ca6: //4A 4A 4A
/* 043 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 044 [def:0009] [use:0008] */          A = A >> 1;
/* 045 [def:1800] [use:0008] */  //      ZN = A;
/* 046 [def:0001] [use:0001] */          //trace_PC(0x7CA6);
/* 047 [def:0001] [use:0001] */      case 0x7CA7: L_7ca7: //4A 4A 28
/* 048 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 049 [def:0009] [use:0008] */          A = A >> 1;
/* 050 [def:1800] [use:0008] */  //      ZN = A;
/* 051 [def:0001] [use:0001] */          //trace_PC(0x7CA7);
/* 052 [def:0001] [use:0001] */      case 0x7CA8: L_7ca8: //4A 28 20
/* 053 [def:2000] [use:0008] */  //      C = A & 0x01;
/* 054 [def:0009] [use:0008] */          A = A >> 1;
/* 055 [def:1800] [use:0008] */  //      ZN = A;
/* 056 [def:0001] [use:0001] */          //trace_PC(0x7CA8);
/* 057 [def:0001] [use:0001] */      case 0x7CA9: L_7ca9: //28 20 E5
/* 058 [def:f881] [use:0081] */          P=stack[++S]; // todo: set C, ZN
/* 059 [def:f801] [use:f800] */          P |= 0x20; /* PLP - needs work */
/* 060 [def:0001] [use:0001] */          //trace_PC(0x7CA9);
/* 061 [def:0001] [use:0001] */      case 0x7CAA: L_7caa: //20 E5 79
/* 062 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 063 [def:0001] [use:0001] */          stack[S--] = 0xAC;
/* 064 [def:0001] [use:0001] */          //trace_PC(0x7CAA);
/* 065 [def:0001] [use:0001] */          PC = 0x79e5;
/*                           */          clockticks += 47; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7CAD: L_7cad: //A5 1C D0
/* 001 [def:0009] [use:0001] */          A=ram[0x001C];
/* 002 [def:1801] [use:0008] */          ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7CAD);
/* 004 [def:0001] [use:0001] */      case 0x7CAF: L_7caf: //D0 01 18
/* 005 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 006 [def:0001] [use:0001] */          {
/* 007 [def:0001] [use:0001] */              //trace_PC(0x7CAF);
/* 008 [def:0001] [use:0001] */              PC = 0x7cb2;
/*                           */              clockticks += 6;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7CAF);
/* 002 [def:0001] [use:0001] */      case 0x7CB1: L_7cb1: //18 A6 1B
/* 003 [def:2001] [use:0000] */          C = 0;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7CB1);
/* 005 [def:0001] [use:0001] */      case 0x7CB2: L_7cb2: //A6 1B B5
/* 006 [def:0001] [use:0001] */          X=ram[0x001B];
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7CB2);
/* 009 [def:0001] [use:0001] */      case 0x7CB4: L_7cb4: //B5 00 20
/* 010 [def:0009] [use:0011] */          A=ram[(unsigned char)(0x00 + X)];
/* 011 [def:1801] [use:0008] */          ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7CB4);
/* 013 [def:0001] [use:0001] */      case 0x7CB6: L_7cb6: //20 E5 79
/* 014 [def:0001] [use:0001] */          stack[S--] = 0x7C;
/* 015 [def:0001] [use:0001] */          stack[S--] = 0xB8;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7CB6);
/* 017 [def:0001] [use:0001] */          PC = 0x79e5;
/*                           */          clockticks += 20; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7CB9: L_7cb9: //C6 1B A6
/* 001 [def:0001] [use:0001] */          ZN=ram[0x001B]-1;
/* 002 [def:0001] [use:0001] */          ram[0x001B] = ZN;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7CB9);
/* 004 [def:0001] [use:0001] */      case 0x7CBB: L_7cbb: //A6 1B C6
/* 005 [def:0001] [use:0001] */          X=ram[0x001B];
/* 006 [def:1801] [use:0010] */          ZN = X;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7CBB);
/* 008 [def:0001] [use:0001] */      case 0x7CBD: L_7cbd: //C6 1C 10
/* 009 [def:0001] [use:0001] */          ZN=ram[0x001C]-1;
/* 010 [def:0001] [use:0001] */          ram[0x001C] = ZN;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7CBD);
/* 012 [def:0001] [use:0001] */      case 0x7CBF: L_7cbf: //10 E1 60
/* 013 [def:0001] [use:1001] */          if (ZN < 0)
/* 014 [def:0001] [use:0001] */          {
/* 015 [def:0001] [use:0001] */              //trace_PC(0x7CBF);
/* 016 [def:0001] [use:0001] */              PC = 0x7ca2;
/*                           */              clockticks += 16;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7CBF);
/* 002 [def:0001] [use:0001] */      case 0x7CC1: L_7cc1: //60 20 C5
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7CC1);
/* 004 [def:0001] [use:0001] */          PC=stack[++S];
/* 005 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 006 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 21; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7CD5: L_7cd5: //A0 00 91
/* 001 [def:0021] [use:0000] */          Y=0x00;
/* 002 [def:1800] [use:0020] */  //      ZN = Y;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7CD5);
/* 004 [def:0001] [use:0001] */      case 0x7CD7: L_7cd7: //91 03 C8
/* 005 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7CD7);
/* 007 [def:0001] [use:0001] */      case 0x7CD9: L_7cd9: //C8 8A 91
/* 008 [def:0021] [use:0020] */          Y++;
/* 009 [def:1800] [use:0020] */  //      ZN = Y;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7CD9);
/* 011 [def:0001] [use:0001] */      case 0x7CDA: L_7cda: //8A 91 03
/* 012 [def:0001] [use:0001] */          A=X;
/* 013 [def:1801] [use:0008] */          ZN = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7CDA);
/* 015 [def:0001] [use:0001] */      case 0x7CDB: L_7cdb: //91 03 4C
/* 016 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0003])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7CDB);
/* 018 [def:0001] [use:0001] */      case 0x7CDD: L_7cdd: //4C 55 7A
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7CDD);
/* 020 [def:0001] [use:0001] */          PC = 0x7a55;
/*                           */          clockticks += 22; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7CE0: L_7ce0: //A2 FE 9A
/* 001 [def:0001] [use:0001] */          X=0xFE;
/* 002 [def:1800] [use:0010] */  //      ZN = X;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7CE0);
/* 004 [def:0001] [use:0001] */      case 0x7CE2: L_7ce2: //9A D8 A2
/* 005 [def:0001] [use:0001] */          S=X;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7CE2);
/* 007 [def:0001] [use:0001] */      case 0x7CE3: L_7ce3: //D8 A2 00
/* 008 [def:0001] [use:0001] */          P &= 0xf7;  //cld
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7CE3);
/* 010 [def:0001] [use:0001] */      case 0x7CE4: L_7ce4: //A2 00 8E
/* 011 [def:0001] [use:0001] */          X=0x00;
/* 012 [def:1800] [use:0010] */  //      ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7CE4);
/* 014 [def:0001] [use:0001] */      case 0x7CE6: L_7ce6: //8E 0F 2C
/* 015 [def:0001] [use:0001] */          ram[0x2C0F] = X;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7CE6);
/* 017 [def:0001] [use:0001] */      case 0x7CE9: L_7ce9: //A9 11 9D
/* 018 [def:0009] [use:0000] */          A=0x11;
/* 019 [def:1800] [use:0008] */  //      ZN = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7CE9);
/* 021 [def:0001] [use:0001] */      case 0x7CEB: L_7ceb: //9D 00 01
/* 022 [def:0001] [use:0019] */          ram[0x0100 + X /* can't wrap */] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7CEB);
/* 024 [def:0001] [use:0001] */      case 0x7CEE: L_7cee: //A8 5D 00
/* 025 [def:0021] [use:0008] */          Y=A;
/* 026 [def:1800] [use:0008] */  //      ZN = A;
/* 027 [def:0001] [use:0001] */          //trace_PC(0x7CEE);
/* 028 [def:0001] [use:0001] */      case 0x7CEF: L_7cef: //5D 00 01
/* 029 [def:0001] [use:0011] */          ZN=ram[(unsigned short)(0x0100 + X)];
/* 030 [def:0001] [use:0001] */          A ^= ZN;
/* 031 [def:1801] [use:0008] */          ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7CEF);
/* 033 [def:0001] [use:0001] */      case 0x7CF2: L_7cf2: //D0 54 98
/* 034 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 035 [def:0001] [use:0001] */          {
/* 036 [def:0001] [use:0001] */              //trace_PC(0x7CF2);
/* 037 [def:0001] [use:0001] */              PC = 0x7d48;
/*                           */              clockticks += 31;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7CF2);
/* 002 [def:0001] [use:0001] */      case 0x7CF4: L_7cf4: //98 0A 90
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7CF4);
/* 006 [def:0001] [use:0001] */      case 0x7CF5: L_7cf5: //0A 90 F3
/* 007 [def:2001] [use:0008] */          C = A & 0x80;
/* 008 [def:0009] [use:0008] */          A = A << 1;
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7CF5);
/* 011 [def:0001] [use:0001] */      case 0x7CF6: L_7cf6: //90 F3 8A
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7CF6);
/* 015 [def:0001] [use:0001] */              PC = 0x7ceb;
/*                           */              clockticks += 37;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7CF6);
/* 002 [def:0001] [use:0001] */      case 0x7CF8: L_7cf8: //8A 95 00
/* 003 [def:0001] [use:0001] */          A=X;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7CF8);
/* 006 [def:0001] [use:0001] */      case 0x7CF9: L_7cf9: //95 00 9D
/* 007 [def:0001] [use:0019] */          ram[(unsigned char)(0x00 + X)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7CF9);
/* 009 [def:0001] [use:0001] */      case 0x7CFB: L_7cfb: //9D 00 01
/* 010 [def:0001] [use:0019] */          ram[0x0100 + X /* can't wrap */] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7CFB);
/* 012 [def:0001] [use:0001] */      case 0x7CFE: L_7cfe: //9D 00 02
/* 013 [def:0001] [use:0019] */          ram[0x0200 + X /* can't wrap */] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7CFE);
/* 015 [def:0001] [use:0001] */      case 0x7D01: L_7d01: //9D 00 03
/* 016 [def:0001] [use:0019] */          ram[0x0300 + X /* can't wrap */] = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7D01);
/* 018 [def:0001] [use:0001] */      case 0x7D04: L_7d04: //9D 00 40
/* 019 [def:0001] [use:0019] */          ram[0x4000 + X /* can't wrap */] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7D04);
/* 021 [def:0001] [use:0001] */      case 0x7D07: L_7d07: //9D 00 41
/* 022 [def:0001] [use:0019] */          ram[0x4100 + X /* can't wrap */] = A;
/* 023 [def:0001] [use:0001] */          //trace_PC(0x7D07);
/* 024 [def:0001] [use:0001] */      case 0x7D0A: L_7d0a: //9D 00 42
/* 025 [def:0001] [use:0019] */          ram[0x4200 + X /* can't wrap */] = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7D0A);
/* 027 [def:0001] [use:0001] */      case 0x7D0D: L_7d0d: //9D 00 43
/* 028 [def:0001] [use:0019] */          ram[0x4300 + X /* can't wrap */] = A;
/* 029 [def:0001] [use:0001] */          //trace_PC(0x7D0D);
/* 030 [def:0001] [use:0001] */      case 0x7D10: L_7d10: //9D 00 44
/* 031 [def:0001] [use:0019] */          ram[0x4400 + X /* can't wrap */] = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7D10);
/* 033 [def:0001] [use:0001] */      case 0x7D13: L_7d13: //9D 00 45
/* 034 [def:0001] [use:0019] */          ram[0x4500 + X /* can't wrap */] = A;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x7D13);
/* 036 [def:0001] [use:0001] */      case 0x7D16: L_7d16: //9D 00 46
/* 037 [def:0001] [use:0019] */          ram[0x4600 + X /* can't wrap */] = A;
/* 038 [def:0001] [use:0001] */          //trace_PC(0x7D16);
/* 039 [def:0001] [use:0001] */      case 0x7D19: L_7d19: //9D 00 47
/* 040 [def:0001] [use:0019] */          ram[0x4700 + X /* can't wrap */] = A;
/* 041 [def:0001] [use:0001] */          //trace_PC(0x7D19);
/* 042 [def:0001] [use:0001] */      case 0x7D1C: L_7d1c: //CA D0 CA
/* 043 [def:0011] [use:0010] */          X--;
/* 044 [def:1801] [use:0010] */          ZN = X;
/* 045 [def:0001] [use:0001] */          //trace_PC(0x7D1C);
/* 046 [def:0001] [use:0001] */      case 0x7D1D: L_7d1d: //D0 CA 8D
/* 047 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 048 [def:0001] [use:0001] */          {
/* 049 [def:0001] [use:0001] */              //trace_PC(0x7D1D);
/* 050 [def:0001] [use:0001] */              PC = 0x7ce9;
/*                           */              clockticks += 102;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D1D);
/* 002 [def:0001] [use:0001] */      case 0x7D1F: L_7d1f: //8D 00 34
/* 003 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7D1F);
/* 005 [def:0001] [use:0001] */      case 0x7D22: L_7d22: //8A 5D 00
/* 006 [def:0001] [use:0001] */          A=X;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D22);
/* 009 [def:0001] [use:0001] */      case 0x7D23: L_7d23: //5D 00 01
/* 010 [def:0001] [use:0011] */          ZN=ram[(unsigned short)(0x0100 + X)];
/* 011 [def:0001] [use:0001] */          A ^= ZN;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7D23);
/* 014 [def:0001] [use:0001] */      case 0x7D26: L_7d26: //D0 20 9D
/* 015 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7D26);
/* 018 [def:0001] [use:0001] */              PC = 0x7d48;
/*                           */              clockticks += 114;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D26);
/* 002 [def:0001] [use:0001] */      case 0x7D28: L_7d28: //9D 00 01
/* 003 [def:0001] [use:0019] */          ram[0x0100 + X /* can't wrap */] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7D28);
/* 005 [def:0001] [use:0001] */      case 0x7D2B: L_7d2b: //E8 2C 07
/* 006 [def:0011] [use:0010] */          X++;
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D2B);
/* 009 [def:0001] [use:0001] */      case 0x7D2C: L_7d2c: //2C 07 20
/* 010 [def:1101] [use:0001] */          ZN=ram[0x2007];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 011 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 012 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7D2C);
/* 014 [def:0001] [use:0001] */      case 0x7D2F: L_7d2f: //10 05 8A
/* 015 [def:0001] [use:1001] */          if (ZN < 0)
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7D2F);
/* 018 [def:0001] [use:0001] */              PC = 0x7d36;
/*                           */              clockticks += 127;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D2F);
/* 002 [def:0001] [use:0001] */      case 0x7D36: L_7d36: //E0 FB 90
/* 003 [def:0101] [use:0000] */          ZN=0xFB;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7D36);
/* 007 [def:0001] [use:0001] */      case 0x7D38: L_7d38: //90 E8 A2
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x7D38);
/* 011 [def:0001] [use:0001] */              PC = 0x7d22;
/*                           */              clockticks += 132;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D38);
/* 002 [def:0001] [use:0001] */      case 0x7D3A: L_7d3a: //A2 00 8A
/* 003 [def:0001] [use:0001] */          X=0x00;
/* 004 [def:1800] [use:0010] */  //      ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D3A);
/* 006 [def:0001] [use:0001] */      case 0x7D3C: L_7d3c: //8A 55 00
/* 007 [def:0001] [use:0001] */          A=X;
/* 008 [def:1800] [use:0008] */  //      ZN = A;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7D3C);
/* 010 [def:0001] [use:0001] */      case 0x7D3D: L_7d3d: //55 00 D0
/* 011 [def:0001] [use:0011] */          temp=(0x0000 + X)&0xFF;
/* 012 [def:0001] [use:0001] */          ZN=ram[temp];
/* 013 [def:0001] [use:0001] */          A ^= ZN;
/* 014 [def:1801] [use:0008] */          ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7D3D);
/* 016 [def:0001] [use:0001] */      case 0x7D3F: L_7d3f: //D0 07 A9
/* 017 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 018 [def:0001] [use:0001] */          {
/* 019 [def:0001] [use:0001] */              //trace_PC(0x7D3F);
/* 020 [def:0001] [use:0001] */              PC = 0x7d48;
/*                           */              clockticks += 143;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D3F);
/* 002 [def:0001] [use:0001] */      case 0x7D41: L_7d41: //A9 11 95
/* 003 [def:0009] [use:0000] */          A=0x11;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D41);
/* 006 [def:0001] [use:0001] */      case 0x7D43: L_7d43: //95 00 A8
/* 007 [def:0001] [use:0019] */          ram[(unsigned char)(0x00 + X)] = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D43);
/* 009 [def:0001] [use:0001] */      case 0x7D45: L_7d45: //A8 55 00
/* 010 [def:0021] [use:0008] */          Y=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7D45);
/* 013 [def:0001] [use:0001] */      case 0x7D46: L_7d46: //55 00 D0
/* 014 [def:0001] [use:0011] */          temp=(0x0000 + X)&0xFF;
/* 015 [def:0001] [use:0001] */          ZN=ram[temp];
/* 016 [def:0001] [use:0001] */          A ^= ZN;
/* 017 [def:1801] [use:0008] */          ZN = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7D46);
/* 019 [def:0001] [use:0001] */      case 0x7D48: L_7d48: //D0 41 98
/* 020 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 021 [def:0001] [use:0001] */          {
/* 022 [def:0001] [use:0001] */              //trace_PC(0x7D48);
/* 023 [def:0001] [use:0001] */              PC = 0x7d8b;
/*                           */              clockticks += 158;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D48);
/* 002 [def:0001] [use:0001] */      case 0x7D4A: L_7d4a: //98 0A 90
/* 003 [def:0001] [use:0001] */          A=Y;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D4A);
/* 006 [def:0001] [use:0001] */      case 0x7D4B: L_7d4b: //0A 90 F5
/* 007 [def:2001] [use:0008] */          C = A & 0x80;
/* 008 [def:0009] [use:0008] */          A = A << 1;
/* 009 [def:1801] [use:0008] */          ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7D4B);
/* 011 [def:0001] [use:0001] */      case 0x7D4C: L_7d4c: //90 F5 A0
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7D4C);
/* 015 [def:0001] [use:0001] */              PC = 0x7d43;
/*                           */              clockticks += 164;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D4C);
/* 002 [def:0001] [use:0001] */      case 0x7D4E: L_7d4e: //A0 00 94
/* 003 [def:0021] [use:0000] */          Y=0x00;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D4E);
/* 006 [def:0001] [use:0001] */      case 0x7D50: L_7d50: //94 00 CA
/* 007 [def:0001] [use:0011] */          temp=(0x0000 + X)&0xFF;
/* 008 [def:0001] [use:0001] */          ram[temp] = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7D50);
/* 010 [def:0001] [use:0001] */      case 0x7D52: L_7d52: //CA D0 E7
/* 011 [def:0011] [use:0010] */          X--;
/* 012 [def:1801] [use:0010] */          ZN = X;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7D52);
/* 014 [def:0001] [use:0001] */      case 0x7D53: L_7d53: //D0 E7 8D
/* 015 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7D53);
/* 018 [def:0001] [use:0001] */              PC = 0x7d3c;
/*                           */              clockticks += 175;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D53);
/* 002 [def:0001] [use:0001] */      case 0x7D55: L_7d55: //8D 00 34
/* 003 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7D55);
/* 005 [def:0001] [use:0001] */      case 0x7D58: L_7d58: //A9 02 85
/* 006 [def:0009] [use:0000] */          A=0x02;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D58);
/* 009 [def:0001] [use:0001] */      case 0x7D5A: L_7d5a: //85 01 98
/* 010 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7D5A);
/* 012 [def:0001] [use:0001] */      case 0x7D5C: L_7d5c: //98 51 00
/* 013 [def:0001] [use:0001] */          A=Y;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7D5C);
/* 016 [def:0001] [use:0001] */      case 0x7D5D: L_7d5d: //51 00 D0
/* 017 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0001]<<8)|ram[0x0000])+Y)]; /* Assume it won't wrap at 64K */
/* 018 [def:1801] [use:0008] */          ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7D5D);
/* 020 [def:0001] [use:0001] */      case 0x7D5F: L_7d5f: //D0 2E A9
/* 021 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 022 [def:0001] [use:0001] */          {
/* 023 [def:0001] [use:0001] */              //trace_PC(0x7D5F);
/* 024 [def:0001] [use:0001] */              PC = 0x7d8f;
/*                           */              clockticks += 193;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D5F);
/* 002 [def:0001] [use:0001] */      case 0x7D61: L_7d61: //A9 11 91
/* 003 [def:0009] [use:0000] */          A=0x11;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D61);
/* 006 [def:0001] [use:0001] */      case 0x7D63: L_7d63: //91 00 AA
/* 007 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0000])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D63);
/* 009 [def:0001] [use:0001] */      case 0x7D65: L_7d65: //AA 51 00
/* 010 [def:0011] [use:0008] */          X=A;
/* 011 [def:1800] [use:0008] */  //      ZN = A;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7D65);
/* 013 [def:0001] [use:0001] */      case 0x7D66: L_7d66: //51 00 D0
/* 014 [def:0001] [use:0021] */          A ^= ram[(unsigned short)(((ram[0x0001]<<8)|ram[0x0000])+Y)]; /* Assume it won't wrap at 64K */
/* 015 [def:1801] [use:0008] */          ZN = A;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7D66);
/* 017 [def:0001] [use:0001] */      case 0x7D68: L_7d68: //D0 25 91
/* 018 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x7D68);
/* 021 [def:0001] [use:0001] */              PC = 0x7d8f;
/*                           */              clockticks += 211;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D68);
/* 002 [def:0001] [use:0001] */      case 0x7D6A: L_7d6a: //91 00 8A
/* 003 [def:0001] [use:0029] */          ram[(unsigned short)(*(((unsigned short *)&ram[0x0000])+Y))] = A; /* Is (ind),Y handled correctly??? */
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7D6A);
/* 005 [def:0001] [use:0001] */      case 0x7D6C: L_7d6c: //8A 0A 90
/* 006 [def:0001] [use:0001] */          A=X;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7D6C);
/* 009 [def:0001] [use:0001] */      case 0x7D6D: L_7d6d: //0A 90 F3
/* 010 [def:2001] [use:0008] */          C = A & 0x80;
/* 011 [def:0009] [use:0008] */          A = A << 1;
/* 012 [def:1801] [use:0008] */          ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7D6D);
/* 014 [def:0001] [use:0001] */      case 0x7D6E: L_7d6e: //90 F3 C8
/* 015 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 016 [def:0001] [use:0001] */          {
/* 017 [def:0001] [use:0001] */              //trace_PC(0x7D6E);
/* 018 [def:0001] [use:0001] */              PC = 0x7d63;
/*                           */              clockticks += 223;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D6E);
/* 002 [def:0001] [use:0001] */      case 0x7D70: L_7d70: //C8 D0 E9
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1801] [use:0020] */          ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D70);
/* 006 [def:0001] [use:0001] */      case 0x7D71: L_7d71: //D0 E9 8D
/* 007 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7D71);
/* 010 [def:0001] [use:0001] */              PC = 0x7d5c;
/*                           */              clockticks += 227;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D71);
/* 002 [def:0001] [use:0001] */      case 0x7D73: L_7d73: //8D 00 34
/* 003 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7D73);
/* 005 [def:0001] [use:0001] */      case 0x7D76: L_7d76: //E6 01 A6
/* 006 [def:1801] [use:0001] */          ZN=++ram[0x0001];
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7D76);
/* 008 [def:0001] [use:0001] */      case 0x7D78: L_7d78: //A6 01 E0
/* 009 [def:0001] [use:0001] */          X=ram[0x0001];
/* 010 [def:1800] [use:0010] */  //      ZN = X;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7D78);
/* 012 [def:0001] [use:0001] */      case 0x7D7A: L_7d7a: //E0 04 90
/* 013 [def:0101] [use:0000] */          ZN=0x04;
/* 014 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 015 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 016 [def:0001] [use:0001] */          //trace_PC(0x7D7A);
/* 017 [def:0001] [use:0001] */      case 0x7D7C: L_7d7c: //90 DE A9
/* 018 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 019 [def:0001] [use:0001] */          {
/* 020 [def:0001] [use:0001] */              //trace_PC(0x7D7C);
/* 021 [def:0001] [use:0001] */              PC = 0x7d5c;
/*                           */              clockticks += 244;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D7C);
/* 002 [def:0001] [use:0001] */      case 0x7D7E: L_7d7e: //A9 40 E0
/* 003 [def:0009] [use:0000] */          A=0x40;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D7E);
/* 006 [def:0001] [use:0001] */      case 0x7D80: L_7d80: //E0 40 90
/* 007 [def:0101] [use:0000] */          ZN=0x40;
/* 008 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 009 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7D80);
/* 011 [def:0001] [use:0001] */      case 0x7D82: L_7d82: //90 D6 E0
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7D82);
/* 015 [def:0001] [use:0001] */              PC = 0x7d5a;
/*                           */              clockticks += 252;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D82);
/* 002 [def:0001] [use:0001] */      case 0x7D84: L_7d84: //E0 48 90
/* 003 [def:0101] [use:0000] */          ZN=0x48;
/* 004 [def:2001] [use:0110] */          C = (X + 0x100 - ZN > 0xff);
 /* 005 [def:1801] [use:0110] */          ZN=/*+0x100*/X-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7D84);
/* 007 [def:0001] [use:0001] */      case 0x7D86: L_7d86: //90 D4 B0
/* 008 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x7D86);
/* 011 [def:0001] [use:0001] */              PC = 0x7d5c;
/*                           */              clockticks += 257;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D86);
/* 002 [def:0001] [use:0001] */      case 0x7D88: L_7d88: //B0 72 64
/* 003 [def:0001] [use:2001] */          if (C)
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x7D88);
/* 006 [def:0001] [use:0001] */              PC = 0x7dfc;
/*                           */              clockticks += 259;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7D88);
/* 002 [def:0001] [use:0001] */      case 0x7D8B: L_7d8b: //A0 00 F0
/* 003 [def:0020] [use:0000] */  //      Y=0x00;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7D8B);
/* 006 [def:0001] [use:0001] */      case 0x7D8F: L_7d8f: //A0 00 A6
/* 007 [def:0020] [use:0000] */  //      Y=0x00;
/* 008 [def:1800] [use:0020] */  //      ZN = Y;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7D8F);
/* 010 [def:0001] [use:0001] */      case 0x7DFC: L_7dfc: //A9 00 A8
/* 011 [def:0009] [use:0000] */          A=0x00;
/* 012 [def:1800] [use:0008] */  //      ZN = A;
/* 013 [def:0001] [use:0001] */          //trace_PC(0x7DFC);
/* 014 [def:0001] [use:0001] */      case 0x7DFE: L_7dfe: //A8 AA A9
/* 015 [def:0021] [use:0008] */          Y=A;
/* 016 [def:1800] [use:0008] */  //      ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7DFE);
/* 018 [def:0001] [use:0001] */      case 0x7DFF: L_7dff: //AA A9 48
/* 019 [def:0011] [use:0008] */          X=A;
/* 020 [def:1800] [use:0008] */  //      ZN = A;
/* 021 [def:0001] [use:0001] */          //trace_PC(0x7DFF);
/* 022 [def:0001] [use:0001] */      case 0x7E00: L_7e00: //A9 48 85
/* 023 [def:0009] [use:0000] */          A=0x48;
/* 024 [def:1800] [use:0008] */  //      ZN = A;
/* 025 [def:0001] [use:0001] */          //trace_PC(0x7E00);
/* 026 [def:0001] [use:0001] */      case 0x7E02: L_7e02: //85 0A A9
/* 027 [def:0001] [use:0008] */          ram[0x000A] = A;
/* 028 [def:0001] [use:0001] */          //trace_PC(0x7E02);
/* 029 [def:0001] [use:0001] */      case 0x7E04: L_7e04: //A9 07 85
/* 030 [def:0009] [use:0000] */          A=0x07;
/* 031 [def:1800] [use:0008] */  //      ZN = A;
/* 032 [def:0001] [use:0001] */          //trace_PC(0x7E04);
/* 033 [def:0001] [use:0001] */      case 0x7E06: L_7e06: //85 0C A9
/* 034 [def:0001] [use:0008] */          ram[0x000C] = A;
/* 035 [def:0001] [use:0001] */          //trace_PC(0x7E06);
/* 036 [def:0001] [use:0001] */      case 0x7E08: L_7e08: //A9 55 18
/* 037 [def:0009] [use:0000] */          A=0x55;
/* 038 [def:1800] [use:0008] */  //      ZN = A;
/* 039 [def:0001] [use:0001] */          //trace_PC(0x7E08);
/* 040 [def:0001] [use:0001] */      case 0x7E0A: L_7e0a: //18 71 09
/* 041 [def:2001] [use:0000] */          C = 0;
/* 042 [def:0001] [use:0001] */          //trace_PC(0x7E0A);
/* 043 [def:0001] [use:0001] */      case 0x7E0B: L_7e0b: //71 09 C8
/* 044 [def:0001] [use:0001] */          temp=ram[(unsigned short)(0x0009 + 1)];
/* 045 [def:0001] [use:0001] */          temp<<=8;
/* 046 [def:0001] [use:0001] */          temp|=ram[0x0009];
/* 047 [def:0001] [use:0001] */          temp+=Y;
/* 048 [def:b801] [use:6001] */          ADC(ram[temp]);
/* 049 [def:0001] [use:0001] */          //trace_PC(0x7E0B);
/* 050 [def:0001] [use:0001] */      case 0x7E0D: L_7e0d: //C8 D0 FB
/* 051 [def:0021] [use:0020] */          Y++;
/* 052 [def:1801] [use:0020] */          ZN = Y;
/* 053 [def:0001] [use:0001] */          //trace_PC(0x7E0D);
/* 054 [def:0001] [use:0001] */      case 0x7E0E: L_7e0e: //D0 FB E6
/* 055 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 056 [def:0001] [use:0001] */          {
/* 057 [def:0001] [use:0001] */              //trace_PC(0x7E0E);
/* 058 [def:0001] [use:0001] */              PC = 0x7e0b;
/*                           */              clockticks += 296;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E0E);
/* 002 [def:0001] [use:0001] */      case 0x7E10: L_7e10: //E6 0A C6
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x000A];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E10);
/* 005 [def:0001] [use:0001] */      case 0x7E12: L_7e12: //C6 0C 10
/* 006 [def:0001] [use:0001] */          ZN=ram[0x000C]-1;
/* 007 [def:0001] [use:0001] */          ram[0x000C] = ZN;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7E12);
/* 009 [def:0001] [use:0001] */      case 0x7E14: L_7e14: //10 F5 95
/* 010 [def:0001] [use:1001] */          if (ZN < 0)
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7E14);
/* 013 [def:0001] [use:0001] */              PC = 0x7e0b;
/*                           */              clockticks += 308;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E14);
/* 002 [def:0001] [use:0001] */      case 0x7E16: L_7e16: //95 10 E8
/* 003 [def:0001] [use:0019] */          ram[(unsigned char)(0x10 + X)] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E16);
/* 005 [def:0001] [use:0001] */      case 0x7E18: L_7e18: //E8 8D 00
/* 006 [def:0011] [use:0010] */          X++;
/* 007 [def:1800] [use:0010] */  //      ZN = X;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7E18);
/* 009 [def:0001] [use:0001] */      case 0x7E19: L_7e19: //8D 00 34
/* 010 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7E19);
/* 012 [def:0001] [use:0001] */      case 0x7E1C: L_7e1c: //A5 0A C9
/* 013 [def:0009] [use:0001] */          A=ram[0x000A];
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7E1C);
/* 016 [def:0001] [use:0001] */      case 0x7E1E: L_7e1e: //C9 58 90
/* 017 [def:0101] [use:0000] */          ZN=0x58;
/* 018 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 019 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7E1E);
/* 021 [def:0001] [use:0001] */      case 0x7E20: L_7e20: //90 E0 D0
/* 022 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 023 [def:0001] [use:0001] */          {
/* 024 [def:0001] [use:0001] */              //trace_PC(0x7E20);
/* 025 [def:0001] [use:0001] */              PC = 0x7e02;
/*                           */              clockticks += 326;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E20);
/* 002 [def:0001] [use:0001] */      case 0x7E22: L_7e22: //D0 02 A9
/* 003 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 004 [def:0001] [use:0001] */          {
/* 005 [def:0001] [use:0001] */              //trace_PC(0x7E22);
/* 006 [def:0001] [use:0001] */              PC = 0x7e26;
/*                           */              clockticks += 328;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E22);
/* 002 [def:0001] [use:0001] */      case 0x7E24: L_7e24: //A9 60 C9
/* 003 [def:0009] [use:0000] */          A=0x60;
/* 004 [def:1800] [use:0008] */  //      ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7E24);
/* 006 [def:0001] [use:0001] */      case 0x7E26: L_7e26: //C9 80 90
/* 007 [def:0101] [use:0000] */          ZN=0x80;
/* 008 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 009 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7E26);
/* 011 [def:0001] [use:0001] */      case 0x7E28: L_7e28: //90 D8 8D
/* 012 [def:0001] [use:0001] */          if (C == 0) /* BCC */
/* 013 [def:0001] [use:0001] */          {
/* 014 [def:0001] [use:0001] */              //trace_PC(0x7E28);
/* 015 [def:0001] [use:0001] */              PC = 0x7e02;
/*                           */              clockticks += 336;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E28);
/* 002 [def:0001] [use:0001] */      case 0x7E2A: L_7e2a: //8D 00 03
/* 003 [def:0001] [use:0008] */          ram[0x0300] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E2A);
/* 005 [def:0001] [use:0001] */      case 0x7E2D: L_7e2d: //8D 04 3C
/* 006 [def:0001] [use:0008] */          ram[0x3C04] = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7E2D);
/* 008 [def:0001] [use:0001] */      case 0x7E30: L_7e30: //CD 00 02
/* 009 [def:0101] [use:0001] */          ZN=ram[0x0200];
/* 010 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 011 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 012 [def:0001] [use:0001] */          //trace_PC(0x7E30);
/* 013 [def:0001] [use:0001] */      case 0x7E33: L_7e33: //F0 02 E6
/* 014 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 015 [def:0001] [use:0001] */          {
/* 016 [def:0001] [use:0001] */              //trace_PC(0x7E33);
/* 017 [def:0001] [use:0001] */              PC = 0x7e37;
/*                           */              clockticks += 350;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E33);
/* 002 [def:0001] [use:0001] */      case 0x7E35: L_7e35: //E6 1A AD
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x001A];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E35);
/* 005 [def:0001] [use:0001] */      case 0x7E37: L_7e37: //AD 00 03
/* 006 [def:0009] [use:0001] */          A=ram[0x0300];
/* 007 [def:1801] [use:0008] */          ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7E37);
/* 009 [def:0001] [use:0001] */      case 0x7E3A: L_7e3a: //F0 02 E6
/* 010 [def:0001] [use:0801] */          if (ZN == 0) /* Z flag is set, ie last val was zero */
/* 011 [def:0001] [use:0001] */          {
/* 012 [def:0001] [use:0001] */              //trace_PC(0x7E3A);
/* 013 [def:0001] [use:0001] */              PC = 0x7e3e;
/*                           */              clockticks += 361;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E3A);
/* 002 [def:0001] [use:0001] */      case 0x7E3C: L_7e3c: //E6 1A A9
/* 003 [def:1801] [use:0001] */          ZN=++ram[0x001A];
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E3C);
/* 005 [def:0001] [use:0001] */      case 0x7E3E: L_7e3e: //A9 10 85
/* 006 [def:0009] [use:0000] */          A=0x10;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7E3E);
/* 009 [def:0001] [use:0001] */      case 0x7E40: L_7e40: //85 01 8D
/* 010 [def:0001] [use:0008] */          ram[0x0001] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7E40);
/* 012 [def:0001] [use:0001] */      case 0x7E42: L_7e42: //8D 04 3C
/* 013 [def:0001] [use:0008] */          ram[0x3C04] = A;
/* 014 [def:0001] [use:0001] */          //trace_PC(0x7E42);
/* 015 [def:0001] [use:0001] */      case 0x7E45: L_7e45: //A2 24 AD
/* 016 [def:0001] [use:0001] */          X=0x24;
/* 017 [def:1800] [use:0010] */  //      ZN = X;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7E45);
/* 019 [def:0001] [use:0001] */      case 0x7E47: L_7e47: //AD 01 20
/* 020 [def:0009] [use:0001] */          A=ram[0x2001];
/* 021 [def:1801] [use:0008] */          ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7E47);
/* 023 [def:0001] [use:0001] */      case 0x7E4A: L_7e4a: //10 FB AD
/* 024 [def:0001] [use:1001] */          if (ZN < 0)
/* 025 [def:0001] [use:0001] */          {
/* 026 [def:0001] [use:0001] */              //trace_PC(0x7E4A);
/* 027 [def:0001] [use:0001] */              PC = 0x7e47;
/*                           */              clockticks += 384;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E4A);
/* 002 [def:0001] [use:0001] */      case 0x7E4C: L_7e4c: //AD 01 20
/* 003 [def:0009] [use:0001] */          A=ram[0x2001];
/* 004 [def:1801] [use:0008] */          ZN = A;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7E4C);
/* 006 [def:0001] [use:0001] */      case 0x7E4F: L_7e4f: //30 FB CA
/* 007 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7E4F);
/* 010 [def:0001] [use:0001] */              PC = 0x7e4c;
/*                           */              clockticks += 390;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E4F);
/* 002 [def:0001] [use:0001] */      case 0x7E51: L_7e51: //CA 10 F3
/* 003 [def:0011] [use:0010] */          X--;
/* 004 [def:1801] [use:0010] */          ZN = X;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7E51);
/* 006 [def:0001] [use:0001] */      case 0x7E52: L_7e52: //10 F3 2C
/* 007 [def:0001] [use:1001] */          if (ZN < 0)
/* 008 [def:0001] [use:0001] */          {
/* 009 [def:0001] [use:0001] */              //trace_PC(0x7E52);
/* 010 [def:0001] [use:0001] */              PC = 0x7e47;
/*                           */              clockticks += 394;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E52);
/* 002 [def:0001] [use:0001] */      case 0x7E54: L_7e54: //2C 02 20
/* 003 [def:1101] [use:0001] */          ZN=ram[0x2002];   // N is correct, Z is not.  Asteroids never tests Z after a Bit instruction...
/* 004 [def:0801] [use:0108] */          // DO_Z (ZN & A); // *** Not compatible with our ZN hack!
/* 005 [def:8001] [use:0100] */          P = (P & 0xbf) | (ZN & 0x40); // Set V
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7E54);
/* 007 [def:0001] [use:0001] */      case 0x7E57: L_7e57: //30 FB 8D
/* 008 [def:0001] [use:1001] */          if(/*P*/ZN < 0 /*& 0x80*/)
/* 009 [def:0001] [use:0001] */          {
/* 010 [def:0001] [use:0001] */              //trace_PC(0x7E57);
/* 011 [def:0001] [use:0001] */              PC = 0x7e54;
/*                           */              clockticks += 400;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E57);
/* 002 [def:0001] [use:0001] */      case 0x7E59: L_7e59: //8D 00 34
/* 003 [def:0001] [use:0008] */          ram[0x3400] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E59);
/* 005 [def:0001] [use:0001] */      case 0x7E5C: L_7e5c: //A9 00 85
/* 006 [def:0009] [use:0000] */          A=0x00;
/* 007 [def:1800] [use:0008] */  //      ZN = A;
/* 008 [def:0001] [use:0001] */          //trace_PC(0x7E5C);
/* 009 [def:0001] [use:0001] */      case 0x7E5E: L_7e5e: //85 03 A9
/* 010 [def:0001] [use:0008] */          ram[0x0003] = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7E5E);
/* 012 [def:0001] [use:0001] */      case 0x7E60: L_7e60: //A9 40 85
/* 013 [def:0009] [use:0000] */          A=0x40;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7E60);
/* 016 [def:0001] [use:0001] */      case 0x7E62: L_7e62: //85 04 AD
/* 017 [def:0001] [use:0008] */          ram[0x0004] = A;
/* 018 [def:0001] [use:0001] */          //trace_PC(0x7E62);
/* 019 [def:0001] [use:0001] */      case 0x7E64: L_7e64: //AD 07 20
/* 020 [def:0009] [use:0001] */          A=ram[0x2007];
/* 021 [def:1800] [use:0008] */  //      ZN = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7E64);
/* 023 [def:0001] [use:0001] */      case 0x7E67: L_7e67: //29 80 D0
/* 024 [def:0009] [use:0008] */          A &= 0x80;
/* 025 [def:1801] [use:0008] */          ZN = A;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7E67);
/* 027 [def:0001] [use:0001] */      case 0x7E69: L_7e69: //D0 06 8D
/* 028 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 029 [def:0001] [use:0001] */          {
/* 030 [def:0001] [use:0001] */              //trace_PC(0x7E69);
/* 031 [def:0001] [use:0001] */              PC = 0x7e71;
/*                           */              clockticks += 423;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7E69);
/* 002 [def:0001] [use:0001] */      case 0x7E6B: L_7e6b: //8D FF 01
/* 003 [def:0001] [use:0008] */          ram[0x01FF] = A;
/* 004 [def:0001] [use:0001] */          //trace_PC(0x7E6B);
/* 005 [def:0001] [use:0001] */      case 0x7E6E: L_7e6e: //4C 00 60
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7E6E);
/* 007 [def:0001] [use:0001] */          PC = 0x6000;
/*                           */          clockticks += 429; /*poll_nmi(opadd);*/
/*                           */          return;

/* 000 [def:0001] [use:0001] */      case 0x7E71: L_7e71: //A5 1A F0
/* 001 [def:0008] [use:0001] */  //      A=ram[0x001A];
/* 002 [def:1800] [use:0008] */  //      ZN = A;
/* 003 [def:0001] [use:0001] */          //trace_PC(0x7E71);
/* 004 [def:0001] [use:0001] */      case 0x7FCF: L_7fcf: //A5 76 29
/* 005 [def:0009] [use:0001] */          A=ram[0x0076];
/* 006 [def:1800] [use:0008] */  //      ZN = A;
/* 007 [def:0001] [use:0001] */          //trace_PC(0x7FCF);
/* 008 [def:0001] [use:0001] */      case 0x7FD1: L_7fd1: //29 03 AA
/* 009 [def:0009] [use:0008] */          A &= 0x03;
/* 010 [def:1800] [use:0008] */  //      ZN = A;
/* 011 [def:0001] [use:0001] */          //trace_PC(0x7FD1);
/* 012 [def:0001] [use:0001] */      case 0x7FD3: L_7fd3: //AA AD 0A
/* 013 [def:0011] [use:0008] */          X=A;
/* 014 [def:1800] [use:0008] */  //      ZN = A;
/* 015 [def:0001] [use:0001] */          //trace_PC(0x7FD3);
/* 016 [def:0001] [use:0001] */      case 0x7FD4: L_7fd4: //AD 0A 2C
/* 017 [def:0009] [use:0001] */          A=ram[0x2C0A];
/* 018 [def:1800] [use:0008] */  //      ZN = A;
/* 019 [def:0001] [use:0001] */          //trace_PC(0x7FD4);
/* 020 [def:0001] [use:0001] */      case 0x7FD7: L_7fd7: //95 D5 A0
/* 021 [def:0001] [use:0019] */          ram[(unsigned char)(0xd5 + X)] = A;
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7FD7);
/* 023 [def:0001] [use:0001] */      case 0x7FD9: L_7fd9: //A0 00 A2
/* 024 [def:0021] [use:0000] */          Y=0x00;
/* 025 [def:1800] [use:0020] */  //      ZN = Y;
/* 026 [def:0001] [use:0001] */          //trace_PC(0x7FD9);
/* 027 [def:0001] [use:0001] */      case 0x7FDB: L_7fdb: //A2 04 D5
/* 028 [def:0001] [use:0001] */          X=0x04;
/* 029 [def:1800] [use:0010] */  //      ZN = X;
/* 030 [def:0001] [use:0001] */          //trace_PC(0x7FDB);
/* 031 [def:0001] [use:0001] */      case 0x7FDD: L_7fdd: //D5 D4 D0
/* 032 [def:0101] [use:0011] */          ZN=(0x00D4 + X)&0xFF;
/* 033 [def:0101] [use:0101] */          ZN=ram[ZN];
/* 034 [def:2001] [use:0108] */          C = (A+0x100-ZN>0xff);
/* 035 [def:1801] [use:0108] */          ZN=/*+0x100*/A-ZN;
/* 036 [def:0001] [use:0001] */          //trace_PC(0x7FDD);
/* 037 [def:0001] [use:0001] */      case 0x7FDF: L_7fdf: //D0 01 C8
/* 038 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 039 [def:0001] [use:0001] */          {
/* 040 [def:0001] [use:0001] */              //trace_PC(0x7FDF);
/* 041 [def:0001] [use:0001] */              PC = 0x7fe2;
/*                           */              clockticks += 32;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7FDF);
/* 002 [def:0001] [use:0001] */      case 0x7FE1: L_7fe1: //C8 CA D0
/* 003 [def:0021] [use:0020] */          Y++;
/* 004 [def:1800] [use:0020] */  //      ZN = Y;
/* 005 [def:0001] [use:0001] */          //trace_PC(0x7FE1);
/* 006 [def:0001] [use:0001] */      case 0x7FE2: L_7fe2: //CA D0 F8
/* 007 [def:0011] [use:0010] */          X--;
/* 008 [def:1801] [use:0010] */          ZN = X;
/* 009 [def:0001] [use:0001] */          //trace_PC(0x7FE2);
/* 010 [def:0001] [use:0001] */      case 0x7FE3: L_7fe3: //D0 F8 C0
/* 011 [def:0001] [use:0801] */          if (ZN != 0)  /* If Z flag is clear, ie last val was non-zero */
/* 012 [def:0001] [use:0001] */          {
/* 013 [def:0001] [use:0001] */              //trace_PC(0x7FE3);
/* 014 [def:0001] [use:0001] */              PC = 0x7fdd;
/*                           */              clockticks += 38;
/*                           */              poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */
/*                           */              return;

/* 000 [def:0001] [use:0001] */          }
/* 001 [def:0001] [use:0001] */          //trace_PC(0x7FE3);
/* 002 [def:0001] [use:0001] */      case 0x7FE5: L_7fe5: //C0 04 AD
/* 003 [def:0101] [use:0001] */          ZN=0x04;
/* 004 [def:2001] [use:0120] */          C = (Y+0x100-ZN>0xff); /* Can probably do better? */
/* 005 [def:1800] [use:0120] */  //      ZN=Y/*+0x100*/-ZN;
/* 006 [def:0001] [use:0001] */          //trace_PC(0x7FE5);
/* 007 [def:0001] [use:0001] */      case 0x7FE7: L_7fe7: //AD 08 2C
/* 008 [def:0009] [use:0001] */          A=ram[0x2C08];
/* 009 [def:1800] [use:0008] */  //      ZN = A;
/* 010 [def:0001] [use:0001] */          //trace_PC(0x7FE7);
/* 011 [def:0001] [use:0001] */      case 0x7FEA: L_7fea: //6A 85 D4
/* 012 [def:10001] [use:2000] */          saveflags = C;
/* 013 [def:2001] [use:0008] */          C = A & 0x01;
/* 014 [def:0009] [use:0008] */          A = A >> 1;
/* 015 [def:0009] [use:10008] */          if (saveflags) A |= 0x80;
/* 016 [def:1801] [use:0008] */          ZN = A;
/* 017 [def:0001] [use:0001] */          //trace_PC(0x7FEA);
/* 018 [def:0001] [use:0001] */      case 0x7FEB: L_7feb: //85 D4 60
/* 019 [def:0001] [use:0008] */          ram[0x00D4] = A;
/* 020 [def:0001] [use:0001] */          //trace_PC(0x7FEB);
/* 021 [def:0001] [use:0001] */      case 0x7FED: L_7fed: //60 38 30
/* 022 [def:0001] [use:0001] */          //trace_PC(0x7FED);
/* 023 [def:0001] [use:0001] */          PC=stack[++S];
/* 024 [def:0001] [use:0001] */          PC|=(unsigned short)(stack[++S])<<8;
/* 025 [def:0001] [use:0001] */          PC++;     
/*                           */          clockticks += 54; /*poll_nmi(opadd);*/
/*                           */          return;

//---- THIS IS THE FIRST LINE IN GBOT.C ----

    }

    // Now write the slaved registers back to memory...
    *_p = P; *_a = A; *_x = X; *_y = Y; *_clockticks = clockticks;
}


void do_rom ( char *filename, unsigned short base )
{
  FILE *fp;

  fp=fopen(filename,"rb");
  if(fp==NULL)
  {
    printf("Error opening rom %s\n",filename);
    exit(1);
  }
  fread(xram+base,1,0x800,fp);
  fclose(fp);
}


int main ( void )
{
  unsigned char _P, _A, _X, _Y;
  long _clockticks;
  memset(xram,0,sizeof(xram));
  memset(xram+0x4000,0xb0,0x1000);
  /*
  do_rom ("rom\\036800.02", 0x4800);
  do_rom ("rom\\036799.01", 0x5000);
  do_rom ("rom\\036430.02", 0x6000);
  do_rom ("rom\\036431.02", 0x6800);
  do_rom ("rom\\036432.02", 0x7000);
  do_rom ("rom\\036433.03", 0x7800);
  */

  memcpy(xram+0x4800,deluxe,0x3800);



  xram [0x2c00] = 0xff;
  xram [0x2c01] = 0xff;
  xram [0x2c02] = 0xff;
  xram [0x2c03] = 0xff;
  xram [0x2c04] = 0xff;
  xram [0x2c05] = 0xff;
  xram [0x2c06] = 0xff;
  xram [0x2c07] = 0xff;
  xram [0x2c08] = 0xff;
  xram [0x2c09] = 0xff;
  xram [0x2c0a] = 0xff;
  xram [0x2c0b] = 0xff;
  xram [0x2c0c] = 0xff;
  xram [0x2c0d] = 0xff;
  xram [0x2c0e] = 0xff;
  xram [0x2c0f] = 0xff;

  xram [0x2800] = 0x0;
  xram [0x2801] = 0x0;
  xram [0x2802] = 0xff;
  xram [0x2803] = 0x0;

  xram[0x2403]=0xFF;
  xram[0x2405]=0xFF;
  xram[0x2406]=0xFF;

//void reset6502()
  _A=_X=_Y=_P=_clockticks=0;
  _P |= 0x20;
  S=0xff;

  show=fopen("game.txt","w");
  if(show==NULL) abort();

  memtrace=fopen("gamemem.txt","w");
  if(memtrace==NULL) abort();

  while(1) game(PC, &_P, &_A, &_X, &_Y, &_clockticks);
  exit(0);
  return(1);
}