Shamusworld >> Repos - thunder/blob - src/v6809b.cpp

   1 // Virtual 6809B v1.2P (Last build: 5/30/1998)
   2 // Protected mode version
   3 //
   4 // by James L. Hammons
   5 //
   6 // (c) 1998 Underground Software
   7
   8 #include "v6809b.h"
   9 #include "v6809.h"              // Pull in some funcs...
  10
  11 // Global defs (needed because functions can only return one value.
  12 //              Maybe you could use a struct to pass multiple values, but
  13 //              what a pain in the ass! This way makes a little more sense
  14 //              to me.)
  15
  16 WORD pcrB, xrB, yrB, srB, urB;  // Double byte registers
  17 BYTE ccrB, arB, brB, dprB;      // Single byte registers
  18 long iclockB;                   // Instruction clock
  19 bool illegalB = false;          // Illegal instruction executed flag
  20
  21 static WORD addr;               // Temporary variables common to all funcs...
  22 static BYTE tmp;
  23
  24 extern BYTE FetchB();           // You need to define these functions
  25 extern WORD FetchWB();          // externally because every hardware situation
  26 extern BYTE RdMemB(WORD);       // is going to be different...
  27 extern void WrMemB(WORD, BYTE);
  28
  29 void (* exec_op0B[256])();  // Array of page zero opcode functions...
  30 void (* exec_op1B[256])();  // Array of page one opcode functions...
  31 void (* exec_op2B[256])();  // Array of page two opcode functions...
  32
  33 //
  34 // Function to read TFR/EXG post byte
  35 //
  36 WORD ReadEXGB(BYTE code)
  37 {
  38   WORD retval;
  39
  40   switch(code)
  41   {
  42     case 0:  retval = (arB<<8) | brB;  break;
  43     case 1:  retval = xrB;  break;
  44     case 2:  retval = yrB;  break;
  45     case 3:  retval = urB;  break;
  46     case 4:  retval = srB;  break;
  47     case 5:  retval = pcrB;  break;
  48     case 8:  retval = arB;  break;
  49     case 9:  retval = brB;  break;
  50     case 10: retval = ccrB;  break;
  51     case 11: retval = dprB;  break;
  52     default: retval = 0xFF;
  53   }
  54   return(retval);
  55 }
  56
  57 //
  58 // Function to set TFR/EXG data
  59 //
  60 void WriteEXGB(BYTE code, WORD data)
  61 {
  62   switch(code)
  63   {
  64     case 0:  { arB = data>>8; brB = data&0xFF;  break; }
  65     case 1:  xrB = data;  break;
  66     case 2:  yrB = data;  break;
  67     case 3:  urB = data;  break;
  68     case 4:  srB = data;  break;
  69     case 5:  pcrB = data;  break;
  70     case 8:  arB = data&0xFF;  break;
  71     case 9:  brB = data&0xFF;  break;
  72     case 10: ccrB = data&0xFF;  break;
  73     case 11: dprB = data&0xFF;  break;
  74   }
  75 }
  76
  77 //
  78 // Function to decode register data
  79 //
  80 WORD DecodeRegB(BYTE reg)
  81 {
  82   WORD retval;
  83
  84   switch(reg)
  85   {
  86     case 0:  retval = xrB;  break;
  87     case 1:  retval = yrB;  break;
  88     case 2:  retval = urB;  break;
  89     case 3:  retval = srB;  break;
  90   }
  91   return(retval);
  92 }
  93
  94 //
  95 // Function to decode IDX data
  96 //
  97 WORD DecodeIDXB(BYTE code)
  98 {
  99   WORD addr, woff;
 100   BYTE reg = (code&0x60)>>5, idxind = (code&0x10)>>4, lo_nyb = code&0x0F;
 101
 102   if (!(code&0x80))      // Hi bit unset? Then decode 4 bit offset
 103   {
 104     addr = DecodeRegB(reg) + (idxind ? lo_nyb-16 : lo_nyb);
 105   }
 106   else
 107   {
 108     if (idxind)
 109     {
 110       switch(lo_nyb)
 111       {
 112         case 1:  { woff = DecodeRegB(reg);
 113                    addr = (RdMemB(woff)<<8) | RdMemB(woff+1);
 114                    switch(reg)
 115                    {
 116                      case 0:  xrB++;  xrB++;  break;
 117                      case 1:  yrB++;  yrB++;  break;
 118                      case 2:  urB++;  urB++;  break;
 119                      case 3:  srB++;  srB++;  break;
 120                    }
 121                    break; }
 122         case 3:  { switch(reg)
 123                    {
 124                      case 0:  xrB--;  xrB--;  break;
 125                      case 1:  yrB--;  yrB--;  break;
 126                      case 2:  urB--;  urB--;  break;
 127                      case 3:  srB--;  srB--;  break;
 128                    }
 129                    woff = DecodeRegB(reg);
 130                    addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 131         case 4:  { woff = DecodeRegB(reg);
 132                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 133         case 5:  { woff = DecodeRegB(reg) + SignedB(brB);
 134                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 135         case 6:  { woff = DecodeRegB(reg) + SignedB(arB);
 136                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 137         case 8:  { woff = DecodeRegB(reg) + SignedB(FetchB());
 138                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 139         case 9:  { woff = DecodeRegB(reg) + SignedW(FetchWB());
 140                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 141         case 11: { woff = DecodeRegB(reg) + SignedW((arB<<8) | brB);
 142                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 143         case 12: { woff = pcrB + SignedB(FetchB());
 144                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 145         case 13: { woff = pcrB + SignedW(FetchWB());
 146                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 147         case 15: { woff = FetchWB();
 148                   addr = (RdMemB(woff)<<8) | RdMemB(woff+1);  break; }
 149       }
 150     }
 151     else
 152     {
 153     switch(lo_nyb)
 154       {
 155         case 0:  { addr = DecodeRegB(reg);
 156                    switch(reg)
 157                    {
 158                      case 0:  xrB++;  break;
 159                      case 1:  yrB++;  break;
 160                      case 2:  urB++;  break;
 161                      case 3:  srB++;  break;
 162                    }
 163                    break; }
 164         case 1:  { addr = DecodeRegB(reg);
 165                    switch(reg)
 166                    {
 167                      case 0:  xrB++;  xrB++;  break;
 168                      case 1:  yrB++;  yrB++;  break;
 169                      case 2:  urB++;  urB++;  break;
 170                      case 3:  srB++;  srB++;  break;
 171                    }
 172                    break; }
 173         case 2:  { switch(reg)
 174                    {
 175                      case 0:  xrB--;  break;
 176                      case 1:  yrB--;  break;
 177                      case 2:  urB--;  break;
 178                      case 3:  srB--;  break;
 179                    }
 180                    addr = DecodeRegB(reg);  break; }
 181         case 3:  { switch(reg)
 182                    {
 183                      case 0:  xrB--;  xrB--;  break;
 184                      case 1:  yrB--;  yrB--;  break;
 185                      case 2:  urB--;  urB--;  break;
 186                      case 3:  srB--;  srB--;  break;
 187                    }
 188                    addr = DecodeRegB(reg);  break; }
 189         case 4:  { addr = DecodeRegB(reg);  break; }
 190         case 5:  { addr = DecodeRegB(reg) + SignedB(brB);  break; }
 191         case 6:  { addr = DecodeRegB(reg) + SignedB(arB);  break; }
 192         case 8:  { addr = DecodeRegB(reg) + SignedB(FetchB());  break; }
 193         case 9:  { addr = DecodeRegB(reg) + SignedW(FetchWB());  break; }
 194         case 11: { addr = DecodeRegB(reg) + SignedW((arB<<8) | brB);  break; }
 195         case 12: { addr = pcrB + SignedB(FetchB());  break; }
 196         case 13: { addr = pcrB + SignedW(FetchWB());  break; }
 197       }
 198     }
 199   }
 200   return(addr);
 201 }
 202
 203 //
 204 // Page zero instructions...
 205 //
 206
 207 void BOp00(void)  // NEG DP
 208 {
 209   addr = (dprB<<8) | FetchB();
 210   tmp = 256 - RdMemB(addr);
 211   WrMemB(addr, tmp);
 212   (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 213   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 214   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 215   (tmp > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
 216   iclockB += 6;
 217 }
 218 void BOp03(void)  // COM DP
 219 {
 220   addr = (dprB<<8) | FetchB();
 221   tmp = 0xFF ^ RdMemB(addr);
 222   WrMemB(addr, tmp);
 223   ccrB &= 0xFD;  ccrB |= 0x01;               // CLV SEC
 224   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 225   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 226   iclockB += 6;
 227 }
 228 void BOp04(void)  // LSR DP
 229 {
 230   addr = (dprB<<8) | FetchB();
 231   tmp = RdMemB(addr);
 232   (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift low bit into carry
 233   tmp >>= 1;  WrMemB(addr, tmp);
 234   ccrB &= 0xF7;                             // CLN
 235   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 236   iclockB += 6;
 237 }
 238 void BOp06(void)  // ROR DP
 239 {
 240   addr = (dprB<<8) | FetchB();  BYTE tmp2 = RdMemB(addr);
 241   tmp = (tmp2>>1) + (ccrB&0x01)*128;
 242   WrMemB(addr, tmp);
 243   (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
 244   (tmp == 0  ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 245   (tmp&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 246   iclockB += 6;
 247 }
 248 void BOp07(void)  // ASR DP
 249 {
 250   addr = (dprB<<8) | FetchB();  tmp = RdMemB(addr);
 251   (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift bit into carry
 252   tmp >>= 1;
 253   if (tmp&0x40)  tmp |= 0x80;              // Set Neg if it was set
 254   WrMemB(addr, tmp);
 255   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 256   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 257   iclockB += 6;
 258 }
 259 void BOp08(void)  // LSL DP
 260 {
 261   addr = (dprB<<8) | FetchB(); // NEEDS OVERFLOW ADJUSTMENT
 262   tmp = RdMemB(addr);
 263   (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift hi bit into carry
 264   tmp <<= 1;
 265   WrMemB(addr, tmp);
 266   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 267   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 268   iclockB += 6;
 269 }
 270 void BOp09(void)  // ROL DP
 271 {
 272   addr = (dprB<<8) | FetchB();  BYTE tmp2 = RdMemB(addr);
 273   tmp = (tmp2<<1) + (ccrB&0x01);
 274   WrMemB(addr, tmp);
 275   (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
 276   ((tmp2&0x80)^((tmp2<<1)&0x80) ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 277   (tmp == 0  ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 278   (tmp&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 279   iclockB += 6;
 280 }
 281 void BOp0A(void)  // DEC DP
 282 {
 283   addr = (dprB<<8) | FetchB();
 284   tmp = RdMemB(addr) - 1;
 285   WrMemB(addr, tmp);
 286   (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 287   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 288   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 289   iclockB += 6;
 290 }
 291 void BOp0C(void)  // INC DP
 292 {
 293   addr = (dprB<<8) | FetchB();
 294   tmp = RdMemB(addr) + 1;
 295   WrMemB(addr, tmp);
 296   (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 297   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 298   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 299   iclockB += 6;
 300 }
 301 void BOp0D(void)  // TST DP
 302 {
 303   tmp = RdMemB((dprB<<8)|FetchB());
 304   ccrB &= 0xFD;                              // CLV
 305   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 306   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 307   iclockB += 6;
 308 }
 309 void BOp0E(void)  // JMP DP
 310 {
 311   pcrB = (dprB<<8) | FetchB();
 312   iclockB += 3;
 313 }
 314 void BOp0F(void)  // CLR DP
 315 {
 316   WrMemB((dprB<<8)|FetchB(), 0);
 317   ccrB &= 0xF0;  ccrB |= 0x04;                // CLN, SEZ, CLV, CLC
 318   iclockB += 6;
 319 }
 320 void BOp12(void)  // NOP
 321 {
 322   iclockB += 2;
 323 }
 324 void BOp13(void)  // SYNC
 325 {
 326   iclockB += 2;
 327 }
 328 void BOp16(void)  // LBRA
 329 {
 330   pcrB += SignedW(FetchWB());
 331   iclockB += 5;
 332 }
 333 void BOp17(void)  // LBSR
 334 {
 335   addr = FetchWB();
 336   WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);
 337   pcrB += SignedW(addr);
 338   iclockB += 9;
 339 }
 340 void BOp19(void)  // DAA
 341 {
 342   /*if ((ccrB&0x20) || ((arB&0x0F) > 0x09))    // H set or lo nyb too big?
 343   {
 344     arB += 0x06;  ccrB |= 0x20;              // Then adjust & set half carry
 345   }
 346   if ((ccrB&0x01) || (arB > 0x9F))           // C set or hi nyb too big?
 347   {
 348     arB += 0x60;  ccrB |= 0x01;              // Then adjust & set carry
 349   }
 350   ccrB &= 0xF1;                             // CL NZV
 351   if (arB == 0)  ccrB |= 0x04;               // Adjust Zero flag
 352   if (arB&0x80)  ccrB |= 0x08;               // Adjust Negative flag
 353   iclockB += 2;  //*/
 354
 355         BYTE msn, lsn;       // Will this work??
 356         WORD t, cf = 0;
 357         msn=arB & 0xf0; lsn=arB & 0x0f;
 358         if( lsn>0x09 || ccrB&0x20 ) cf |= 0x06;
 359         if( msn>0x80 && lsn>0x09 ) cf |= 0x60;
 360         if( msn>0x90 || ccrB&0x01 ) cf |= 0x60;
 361         t = cf + arB;
 362         ccrB &= 0xF1;   // CL NZV
 363         //CLR_NZV; /* keep carry from previous operation */
 364         if (arB == 0)  ccrB |= 0x04;   // Adjust Zero flag
 365         if (arB&0x80)  ccrB |= 0x08;   // Adjust Negative flag
 366         //SET_NZ8((byte)t); SET_C8(t);
 367         ccrB |= ((t&0x100)>>8); // Adjust Carry (?)
 368         arB = t;
 369 }
 370 void BOp1A(void)  // ORCC #
 371 {
 372   ccrB |= FetchB();
 373   iclockB += 3;
 374 }
 375 void BOp1C(void)  // ANDCC #
 376 {
 377   ccrB &= FetchB();
 378   iclockB += 3;
 379 }
 380 void BOp1D(void)  // SEX
 381 {
 382   (brB&0x80 ? arB = 0xFF : arB = 0x00);
 383   ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 384   (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 385   iclockB += 2;
 386 }
 387 void BOp1E(void)  // EXG
 388 {
 389   tmp = FetchB();
 390   addr = ReadEXGB(tmp>>4);  WriteEXGB(tmp>>4, ReadEXGB(tmp&0xF));
 391   WriteEXGB(tmp&0xF, addr);
 392   iclockB += 8;
 393 }
 394 void BOp1F(void)  // TFR
 395 {
 396   tmp = FetchB();
 397   WriteEXGB(tmp&0xF, ReadEXGB(tmp>>4));
 398   iclockB += 7;
 399 }
 400 void BOp20(void)  // BRA
 401 {
 402   pcrB += SignedB(FetchB());  // Branch always
 403   iclockB += 3;
 404 }
 405 void BOp21(void)  // BRN
 406 {
 407   FetchB();
 408   iclockB += 3;
 409 }
 410 void BOp22(void)  // BHI
 411 {
 412   tmp = FetchB();
 413   if (!(ccrB&0x05))  pcrB += SignedB(tmp);
 414   iclockB += 3;
 415 }
 416 void BOp23(void)  // BLS
 417 {
 418   tmp = FetchB();
 419   if (ccrB&0x05)  pcrB += SignedB(tmp);
 420   iclockB += 3;
 421 }
 422 void BOp24(void)  // BCC (BHS)
 423 {
 424   tmp = FetchB();
 425   if (!(ccrB&0x01))  pcrB += SignedB(tmp);
 426   iclockB += 3;
 427 }
 428 void BOp25(void)  // BCS (BLO)
 429 {
 430   tmp = FetchB();
 431   if (ccrB&0x01)  pcrB += SignedB(tmp);
 432   iclockB += 3;
 433 }
 434 void BOp26(void)  // BNE
 435 {
 436   tmp = FetchB();
 437   if (!(ccrB&0x04))  pcrB += SignedB(tmp);
 438   iclockB += 3;
 439 }
 440 void BOp27(void)  // BEQ
 441 {
 442   tmp = FetchB();
 443   if (ccrB&0x04)  pcrB += SignedB(tmp);
 444   iclockB += 3;
 445 }
 446 void BOp28(void)  // BVC
 447 {
 448   tmp = FetchB();
 449   if (!(ccrB&0x02))  pcrB += SignedB(tmp);
 450   iclockB += 3;
 451 }
 452 void BOp29(void)  // BVS
 453 {
 454   tmp = FetchB();
 455   if (ccrB&0x02)  pcrB += SignedB(tmp);
 456   iclockB += 3;
 457 }
 458 void BOp2A(void)  // BPL
 459 {
 460   tmp = FetchB();
 461   if (!(ccrB&0x08))  pcrB += SignedB(tmp);
 462   iclockB += 3;
 463 }
 464 void BOp2B(void)  // BMI
 465 {
 466   tmp = FetchB();
 467   if (ccrB&0x08)  pcrB += SignedB(tmp);
 468   iclockB += 3;
 469 }
 470 void BOp2C(void)  // BGE
 471 {
 472   tmp = FetchB();
 473   if (!(((ccrB&0x08) >> 2) ^ (ccrB&0x02)))  pcrB += SignedB(tmp);
 474   iclockB += 3;
 475 }
 476 void BOp2D(void)  // BLT
 477 {
 478   tmp = FetchB();
 479   if (((ccrB&0x08) >> 2) ^ (ccrB&0x02))  pcrB += SignedB(tmp);
 480   iclockB += 3;
 481 }
 482 void BOp2E(void)  // BGT
 483 {
 484   tmp = FetchB();
 485   if (!((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02))))  pcrB += SignedB(tmp);
 486   iclockB += 3;
 487 }
 488 void BOp2F(void)  // BLE
 489 {
 490   tmp = FetchB();
 491   if ((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02)))  pcrB += SignedB(tmp);
 492   iclockB += 3;
 493 }
 494 void BOp30(void)  // LEAX
 495 {
 496   xrB = DecodeIDXB(FetchB());
 497   (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 498   iclockB += 4;
 499 }
 500 void BOp31(void)  // LEAY
 501 {
 502   yrB = DecodeIDXB(FetchB());
 503   (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 504   iclockB += 4;
 505 }
 506 void BOp32(void)  // LEAS
 507 {
 508   srB = DecodeIDXB(FetchB());
 509   (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 510   iclockB += 4;
 511 }
 512 void BOp33(void)  // LEAU
 513 {
 514   urB = DecodeIDXB(FetchB());
 515   (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 516   iclockB += 4;
 517 }
 518 void BOp34(void)  // PSHS
 519 {
 520   tmp = FetchB();
 521   if (tmp&0x80)  { WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8); }
 522   if (tmp&0x40)  { WrMemB(--srB, urB&0xFF);  WrMemB(--srB, urB>>8); }
 523   if (tmp&0x20)  { WrMemB(--srB, yrB&0xFF);  WrMemB(--srB, yrB>>8); }
 524   if (tmp&0x10)  { WrMemB(--srB, xrB&0xFF);  WrMemB(--srB, xrB>>8); }
 525   if (tmp&0x08)  WrMemB(--srB, dprB);
 526   if (tmp&0x04)  WrMemB(--srB, brB);
 527   if (tmp&0x02)  WrMemB(--srB, arB);
 528   if (tmp&0x01)  WrMemB(--srB, ccrB);
 529   iclockB += 5;
 530 }
 531 void BOp35(void)  // PULS
 532 {
 533   tmp = FetchB();
 534   if (tmp&0x01)  ccrB = RdMemB(srB++);
 535   if (tmp&0x02)  arB  = RdMemB(srB++);
 536   if (tmp&0x04)  brB  = RdMemB(srB++);
 537   if (tmp&0x08)  dprB = RdMemB(srB++);
 538   if (tmp&0x10)  xrB  = (RdMemB(srB++)<<8) | RdMemB(srB++);
 539   if (tmp&0x20)  yrB  = (RdMemB(srB++)<<8) | RdMemB(srB++);
 540   if (tmp&0x40)  urB  = (RdMemB(srB++)<<8) | RdMemB(srB++);
 541   if (tmp&0x80)  pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 542   iclockB += 5;
 543 }
 544 void BOp36(void)  // PSHU
 545 {
 546   tmp = FetchB();
 547   if (tmp&0x80)  { WrMemB(--urB, pcrB&0xFF);  WrMemB(--urB, pcrB>>8); }
 548   if (tmp&0x40)  { WrMemB(--urB, srB&0xFF);  WrMemB(--urB, srB>>8); }
 549   if (tmp&0x20)  { WrMemB(--urB, yrB&0xFF);  WrMemB(--urB, yrB>>8); }
 550   if (tmp&0x10)  { WrMemB(--urB, xrB&0xFF);  WrMemB(--urB, xrB>>8); }
 551   if (tmp&0x08)  WrMemB(--urB, dprB);
 552   if (tmp&0x04)  WrMemB(--urB, brB);
 553   if (tmp&0x02)  WrMemB(--urB, arB);
 554   if (tmp&0x01)  WrMemB(--urB, ccrB);
 555   iclockB += 5;
 556 }
 557 void BOp37(void)  // PULU
 558 {
 559   tmp = FetchB();
 560   if (tmp&0x01)  ccrB = RdMemB(urB++);
 561   if (tmp&0x02)  arB  = RdMemB(urB++);
 562   if (tmp&0x04)  brB  = RdMemB(urB++);
 563   if (tmp&0x08)  dprB = RdMemB(urB++);
 564   if (tmp&0x10)  xrB  = (RdMemB(urB++)<<8) | RdMemB(urB++);
 565   if (tmp&0x20)  yrB  = (RdMemB(urB++)<<8) | RdMemB(urB++);
 566   if (tmp&0x40)  srB  = (RdMemB(urB++)<<8) | RdMemB(urB++);
 567   if (tmp&0x80)  pcrB = (RdMemB(urB++)<<8) | RdMemB(urB++);
 568   iclockB += 5;
 569 }
 570 void BOp39(void)  // RTS
 571 {
 572   pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 573   iclockB += 5;
 574 }
 575 void BOp3A(void)  // ABX
 576 {
 577   xrB += brB;
 578   iclockB += 3;
 579 }
 580 void BOp3B(void)  // RTI
 581 {
 582   ccrB = RdMemB(srB++);
 583   if (ccrB&0x80)      // If E flag set, pull all regs
 584   {
 585     arB = RdMemB(srB++);  brB = RdMemB(srB++);  dprB = RdMemB(srB++);
 586     xrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 587     yrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 588     urB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 589     iclockB += 15;
 590   }
 591   else
 592   {
 593     iclockB += 6;
 594   }
 595   pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
 596 }
 597 void BOp3C(void)  // CWAI
 598 {
 599   ccrB &= FetchB();  ccrB |= 0x80;
 600   iclockB += 1000000;             // Force interrupt
 601 }
 602 void BOp3D(void)  // MUL
 603 {
 604   addr = arB * brB;  arB = addr>>8;  brB = addr&0xFF;
 605   (addr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero
 606   (brB&0x80   ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry
 607   iclockB += 11;
 608 }
 609 void BOp3E(void)  // RESET
 610 {
 611 }
 612 void BOp3F(void)  // SWI
 613 {
 614 }
 615 void BOp40(void)  // NEGA
 616 {
 617   arB = 256 - arB;
 618   (arB > 0x7F  ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
 619   (arB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 620   (arB == 0    ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 621   (arB&0x80    ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 622   iclockB += 2;
 623 }
 624 void BOp43(void)  // COMA
 625 {
 626   arB ^= 0xFF;
 627   ccrB &= 0xFD;  ccrB |= 0x01;              // CLV, SEC
 628   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 629   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 630   iclockB += 2;
 631 }
 632 void BOp44(void)  // LSRA
 633 {
 634   (arB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift low bit into carry
 635   arB >>= 1;
 636   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 637   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 638   iclockB += 2;
 639 }
 640 void BOp46(void)  // RORA
 641 {
 642   tmp = arB;  arB = (tmp>>1) + (ccrB&0x01)*128;
 643   (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
 644   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 645   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 646   iclockB += 2;
 647 }
 648 void BOp47(void)  // ASRA
 649 {
 650   (arB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift bit into carry
 651   arB >>= 1;                               // Do the shift
 652   if (arB&0x40)  arB |= 0x80;               // Set neg if it was set
 653   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 654   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 655   iclockB += 2;
 656 }
 657 void BOp48(void)  // LSLA  [Keep checking from here...]
 658 {
 659   (arB&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift hi bit into carry
 660   arB <<= 1;
 661   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 662   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 663   iclockB += 2;
 664 }
 665 void BOp49(void)  // ROLA
 666 {
 667   tmp = arB;  arB = (tmp<<1) + (ccrB&0x01);
 668   (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
 669   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 670   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 671   iclockB += 2;
 672 }
 673 void BOp4A(void)  // DECA
 674 {
 675   arB--;
 676   (arB == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 677   (arB == 0    ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
 678   (arB&0x80    ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
 679   iclockB += 2;
 680 }
 681 void BOp4C(void)  // INCA
 682       {
 683         arB++;
 684         (arB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 685         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 686         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 687         iclockB += 2;
 688       }
 689 void BOp4D(void)  // TSTA
 690       {
 691         ccrB &= 0xFD;                            // Clear oVerflow flag
 692         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 693         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 694         iclockB += 2;
 695       }
 696 void BOp4F(void)  // CLRA
 697 {
 698   arB = 0;
 699   ccrB &= 0xF0;  ccrB |= 0x04;                // Set NZVC
 700   iclockB += 2;
 701 }
 702 void BOp50(void)  // NEGB
 703       {
 704         brB = 256 - brB;
 705 //        ((brB^tmp)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Adjust H carry
 706         (brB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 707         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 708         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 709         (brB > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
 710         iclockB += 2;
 711       }
 712 void BOp53(void)  // COMB
 713       {
 714         brB ^= 0xFF;
 715         ccrB &= 0xFD;  ccrB |= 0x01;              // CLV, SEC
 716         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 717         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 718         iclockB += 2;
 719       }
 720 void BOp54(void)  // LSRB
 721       {
 722         (brB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift low bit into carry
 723         brB >>= 1;
 724         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 725         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 726         iclockB += 2;
 727       }
 728 void BOp56(void)  // RORB
 729       {
 730         tmp = brB;  brB = (brB >> 1) + (ccrB&0x01)*128;
 731         (tmp&0x01 ? ccrB |=0x01 : ccrB &= 0xFE);  // Shift bit into carry
 732         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 733         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 734         iclockB += 2;
 735       }
 736 void BOp57(void)  // ASRB
 737       {
 738         (brB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift bit into carry
 739         brB >>= 1;                               // Do the shift
 740         if (brB&0x40)  brB |= 0x80;               // Set neg if it was set
 741         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 742         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 743         iclockB += 2;
 744       }
 745 void BOp58(void)  // LSLB
 746       {
 747         (brB&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift hi bit into carry
 748         brB <<= 1;
 749         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 750         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 751         iclockB += 2;
 752       }
 753 void BOp59(void)  // ROLB
 754 {
 755   tmp = brB;
 756   brB = (tmp<<1) + (ccrB&0x01);
 757   (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
 758   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 759   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 760   iclockB += 2;
 761 }
 762 void BOp5A(void)  // DECB
 763       {
 764         brB--;
 765         (brB == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 766         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 767         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 768         iclockB += 2;
 769       }
 770 void BOp5C(void)  // INCB
 771       {
 772         brB++;
 773         (brB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 774         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 775         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 776         iclockB += 2;
 777       }
 778 void BOp5D(void)  // TSTB
 779       {
 780         ccrB &= 0xFD;                            // Clear oVerflow flag
 781         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 782         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 783         iclockB += 2;
 784       }
 785 void BOp5F(void)  // CLRB
 786       {
 787         brB = 0;
 788         ccrB &= 0xF0;  ccrB |= 0x04;                // Set NZVC
 789         iclockB += 2;
 790       }
 791 void BOp60(void)  // NEG IDX
 792       {
 793         addr = DecodeIDXB(FetchB());
 794         tmp = RdMemB(addr);  BYTE res = 256 - tmp;
 795         WrMemB(addr, res);
 796 //        ((res^tmp)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Adjust H carry
 797         (res == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 798         (res == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 799         (res&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 800         (res > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
 801         iclockB += 6;
 802       }
 803 void BOp63(void)  // COM IDX
 804       {
 805         addr = DecodeIDXB(FetchB());
 806         tmp = RdMemB(addr) ^ 0xFF;
 807         WrMemB(addr, tmp);
 808         ccrB &= 0xFD;  ccrB |= 0x01;               // CLV, SEC
 809         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 810         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 811         iclockB += 6;
 812       }
 813 void BOp64(void)  // LSR IDX
 814       {
 815         addr = DecodeIDXB(FetchB());
 816         tmp = RdMemB(addr);
 817         (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift low bit into carry
 818         tmp >>= 1;  WrMemB(addr, tmp);
 819         ccrB &= 0xF7;                             // CLN
 820         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 821         iclockB += 6;
 822       }
 823 void BOp66(void)  // ROR IDX
 824       {
 825         addr = DecodeIDXB(FetchB());
 826         tmp = RdMemB(addr);  BYTE tmp2 = tmp;
 827         tmp = (tmp >> 1) + (ccrB&0x01)*128;
 828         WrMemB(addr, tmp);
 829         (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
 830         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 831         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 832         iclockB += 6;
 833       }
 834 void BOp67(void)  // ASR IDX
 835       {
 836         addr = DecodeIDXB(FetchB());
 837         tmp = RdMemB(addr);
 838         (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift bit into carry
 839         tmp >>= 1;
 840         if (tmp&0x40)  tmp |= 0x80;              // Set Neg if it was set
 841         WrMemB(addr, tmp);
 842         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 843         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 844         iclockB += 6;
 845       }
 846 void BOp68(void)  // LSL IDX
 847       {
 848         addr = DecodeIDXB(FetchB());
 849         tmp = RdMemB(addr);
 850         (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift hi bit into carry
 851         tmp <<= 1;
 852         WrMemB(addr, tmp);
 853         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 854         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 855         iclockB += 6;
 856       }
 857 void BOp69(void)  // ROL IDX
 858 {
 859   BYTE tmp2 = RdMemB(DecodeIDXB(FetchB()));
 860   tmp = (tmp2<<1) + (ccrB&0x01);
 861   WrMemB(addr, tmp);
 862   (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
 863   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 864   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 865   iclockB += 6;
 866 }
 867 void BOp6A(void)  // DEC IDX
 868       {
 869   BYTE tmp;  WORD addr;
 870         addr = DecodeIDXB(FetchB());
 871         tmp = RdMemB(addr) - 1;
 872         WrMemB(addr, tmp);
 873         (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 874         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 875         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 876         iclockB += 6;
 877       }
 878 void BOp6C(void)  // INC IDX
 879       {
 880         addr = DecodeIDXB(FetchB());
 881         tmp = RdMemB(addr) + 1;
 882         WrMemB(addr, tmp);
 883         (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 884         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 885         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 886         iclockB += 6;
 887       }
 888 void BOp6D(void)  // TST IDX
 889       {
 890         tmp = RdMemB(DecodeIDXB(FetchB()));
 891         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 892         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 893         iclockB += 6;
 894       }
 895 void BOp6E(void)  // JMP IDX
 896 {
 897   pcrB = DecodeIDXB(FetchB());
 898   iclockB += 3;
 899 }
 900 void BOp6F(void)  // CLR IDX
 901 {
 902   addr = DecodeIDXB(FetchB());
 903   WrMemB(addr, 0);
 904   ccrB &= 0xF0;  ccrB |= 0x04;                // Set NZVC
 905   iclockB += 6;
 906 }
 907 void BOp70(void)  // NEG ABS
 908       {
 909         addr = FetchWB();
 910         tmp = RdMemB(addr);  BYTE res = 256 - tmp;
 911         WrMemB(addr, res);
 912         (res == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
 913         (res == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
 914         (res&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
 915         (res > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
 916         iclockB += 7;
 917       }
 918 void BOp73(void)  // COM ABS
 919       {
 920         addr = FetchWB();
 921         tmp = RdMemB(addr) ^ 0xFF;
 922         WrMemB(addr, tmp);
 923         ccrB &= 0xFD;  ccrB |= 0x01;               // CLV, SEC
 924         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 925         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 926         iclockB += 7;
 927       }
 928 void BOp74(void)  // LSR ABS
 929       {
 930         addr = FetchWB();
 931         tmp = RdMemB(addr);
 932         (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift low bit into carry
 933         tmp >>= 1;  WrMemB(addr, tmp);
 934         ccrB &= 0xF7;                             // CLN
 935         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 936         iclockB += 7;
 937       }
 938 void BOp76(void)  // ROR ABS
 939       {
 940   BYTE tmp;  WORD addr;
 941         addr = FetchWB();
 942         tmp = RdMemB(addr);  BYTE tmp2 = tmp;
 943         tmp = (tmp >> 1) + (ccrB&0x01)*128;
 944         WrMemB(addr, tmp);
 945         (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
 946         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 947         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 948         iclockB += 7;
 949       }
 950 void BOp77(void)  // ASR ABS
 951       {
 952   BYTE tmp;  WORD addr;
 953         addr = FetchWB();
 954         tmp = RdMemB(addr);
 955         (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift bit into carry
 956         tmp >>= 1;
 957         if (tmp&0x40)  tmp |= 0x80;              // Set Neg if it was set
 958         WrMemB(addr, tmp);
 959         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 960         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 961         iclockB += 7;
 962       }
 963 void BOp78(void)  // LSL ABS
 964       {
 965   BYTE tmp;  WORD addr;
 966         addr = FetchWB();
 967         tmp = RdMemB(addr);
 968         (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Shift hi bit into carry
 969         tmp <<= 1;
 970         WrMemB(addr, tmp);
 971         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 972         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 973         iclockB += 7;
 974       }
 975 void BOp79(void)  // ROL ABS
 976 {
 977   BYTE tmp2 = RdMemB(FetchWB());
 978   tmp = (tmp2<<1) + (ccrB&0x01);
 979   WrMemB(addr, tmp);
 980   (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
 981   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
 982   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
 983   iclockB += 7;
 984 }
 985 void BOp7A(void)  // DEC ABS
 986       {
 987   BYTE tmp;  WORD addr;
 988         addr = FetchWB();
 989         tmp = RdMemB(addr) - 1;
 990         WrMemB(addr, tmp);
 991         (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
 992         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
 993         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
 994         iclockB += 7;
 995       }
 996 void BOp7C(void)  // INC ABS
 997       {
 998   BYTE tmp;  WORD addr;
 999         addr = FetchWB();
1000         tmp = RdMemB(addr) + 1;
1001         WrMemB(addr, tmp);
1002         (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
1003         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);    // Adjust Zero flag
1004         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);    // Adjust Negative flag
1005         iclockB += 7;
1006       }
1007 void BOp7D(void)  // TST ABS
1008 {
1009   BYTE tmp = RdMemB(FetchWB());
1010   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);   // Adjust Zero flag
1011   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);   // Adjust Negative flag
1012   iclockB += 7;
1013 }
1014 void BOp7E(void)  // JMP ABS
1015 {
1016   pcrB = FetchWB();
1017   iclockB += 3;
1018 }
1019 void BOp7F(void)  // CLR ABS
1020       {
1021         WrMemB(FetchWB(), 0);
1022         ccrB &= 0xF0;  ccrB |= 0x04;                // Set NZVC
1023         iclockB += 7;
1024       }
1025 void BOp80(void)  // SUBA #
1026 {
1027   BYTE tmp = FetchB();  BYTE as = arB;
1028   arB -= tmp;
1029   (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1030   ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1031   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1032   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1033   iclockB += 2;
1034 }
1035 void BOp81(void)  // CMPA #
1036 {
1037   tmp = FetchB();
1038   BYTE db = arB - tmp;
1039   (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1040   ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1041   (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1042   (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1043   iclockB += 2;
1044 }
1045 void BOp82(void)  // SBCA #
1046 {
1047   tmp = FetchB();  BYTE as = arB;
1048   arB = arB - tmp - (ccrB&0x01);
1049   (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1050   ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1051   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1052   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1053   iclockB += 2;
1054 }
1055 void BOp83(void)  // SUBD #
1056 {
1057   addr = FetchWB();  WORD dr = (arB<<8)|brB, ds = dr;
1058   dr -= addr;
1059   (ds < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1060   ((ds^addr^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1061   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1062   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1063   arB = dr>>8;  brB = dr&0xFF;
1064   iclockB += 4;
1065 }
1066 void BOp84(void)  // ANDA #
1067       {
1068         arB &= FetchB();
1069         ccrB &= 0xFD;                            // Clear oVerflow flag
1070         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1071         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1072         iclockB += 2;
1073       }
1074 void BOp85(void)  // BITA #
1075       {
1076         tmp = arB & FetchB();
1077         ccrB &= 0xFD;                             // Clear oVerflow flag
1078         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1079         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1080         iclockB += 2;
1081       }
1082 void BOp86(void)  // LDA #
1083       {
1084         arB = FetchB();
1085         ccrB &= 0xFD;                            // CLV
1086         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1087         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1088         iclockB += 2;
1089       }
1090 void BOp88(void)  // EORA #
1091       {
1092         arB ^= FetchB();
1093         ccrB &= 0xFD;                            // CLV
1094         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1095         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1096         iclockB += 2;
1097       }
1098 void BOp89(void)  // ADCA #
1099 {
1100   tmp = FetchB();
1101   addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
1102   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry
1103   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1104   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1105   arB = addr & 0xFF;                       // Set accumulator
1106   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero
1107   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative
1108   iclockB += 2;
1109 }
1110 void BOp8A(void)  // ORA #
1111       {
1112         arB |= FetchB();
1113         ccrB &= 0xFD;                            // CLV
1114         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1115         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1116         iclockB += 2;
1117       }
1118 void BOp8B(void)  // ADDA #
1119 {
1120   tmp = FetchB();  addr = arB + tmp;
1121   (addr > 0xFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
1122   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1123   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1124   arB = addr & 0xFF;                       // Set accumulator
1125   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1126   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1127   iclockB += 2;
1128 }
1129 void BOp8C(void)  // CMPX #
1130 {
1131         addr = FetchWB();
1132         WORD dw = xrB - addr;
1133         (xrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1134         ((xrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
1135         (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1136         (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1137         iclockB += 4;
1138 }
1139 void BOp8D(void)  // BSR
1140       {
1141         tmp = FetchB();
1142         WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);
1143         pcrB += SignedB(tmp);
1144         iclockB += 7;
1145       }
1146 void BOp8E(void)  // LDX #
1147       {
1148         xrB = FetchWB();
1149         ccrB &= 0xFD;                              // CLV
1150         (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1151         (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1152         iclockB += 3;
1153       }
1154 void BOp90(void)  // SUBA DP
1155       {
1156         tmp = RdMemB((dprB<<8)|FetchB());  BYTE as = arB;
1157         arB -= tmp;
1158         (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1159         (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1160         (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1161         ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1162         iclockB += 4;
1163       }
1164 void BOp91(void)  // CMPA DP
1165       {
1166         tmp = RdMemB((dprB<<8)|FetchB());
1167         BYTE db = arB - tmp;
1168         (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1169         (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1170         (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1171         ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1172         iclockB += 4;
1173       }
1174 void BOp92(void)  // SBCA DP
1175 {
1176   tmp = RdMemB((dprB<<8)|FetchB());  BYTE as = arB;
1177   arB = arB - tmp - (ccrB&0x01);
1178   (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1179   ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1180   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1181   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1182   iclockB += 4;
1183 }
1184 void BOp93(void)  // SUBD DP
1185 {
1186   addr = (dprB<<8)|FetchB();  WORD dr = (arB<<8)|brB, ds = dr;
1187   WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1188   dr -= adr2;
1189   (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1190   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1191   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1192   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1193   arB = dr>>8;  brB = dr&0xFF;
1194   iclockB += 6;
1195 }
1196 void BOp94(void)  // ANDA DP
1197 {
1198   arB &= RdMemB((dprB<<8)|FetchB());
1199   ccrB &= 0xF1;                   // CLV CLZ CLN
1200   if (arB == 0)  ccrB |= 0x04;     // Adjust Zero flag
1201   if (arB&0x80)  ccrB |= 0x08;     // Adjust Negative flag
1202   iclockB += 4;
1203 }
1204 void BOp95(void)  // BITA DP
1205       {
1206         tmp = arB & RdMemB((dprB<<8)|FetchB());
1207         ccrB &= 0xFD;                             // Clear oVerflow flag
1208         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1209         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1210         iclockB += 4;
1211       }
1212 void BOp96(void)  // LDA DP
1213 {
1214   arB = RdMemB((dprB<<8)|FetchB());
1215   ccrB &= 0xF1;                            // CLN CLZ CLV
1216   if (arB == 0)  ccrB |= 0x04;              // Set Zero flag
1217   if (arB&0x80)  ccrB |= 0x08;              // Set Negative flag
1218   iclockB += 4;
1219 }
1220 void BOp97(void)  // STA DP
1221       {
1222         WrMemB((dprB<<8)|FetchB(), arB);
1223         ccrB &= 0xFD;                            // CLV
1224         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1225         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1226         iclockB += 4;
1227       }
1228 void BOp98(void)  // EORA DP
1229       {
1230         arB ^= RdMemB((dprB<<8)|FetchB());
1231         ccrB &= 0xFD;                            // CLV
1232         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1233         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1234         iclockB += 4;
1235       }
1236 void BOp99(void)  // ADCA DP
1237 {
1238   tmp = RdMemB((dprB<<8)|FetchB());
1239   addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
1240   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry
1241   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1242   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1243   arB = addr & 0xFF;                       // Set accumulator
1244   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero
1245   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative
1246   iclockB += 4;
1247 }
1248 void BOp9A(void)  // ORA DP
1249       {
1250         arB |= RdMemB((dprB<<8)|FetchB());
1251         ccrB &= 0xFD;                            // CLV
1252         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1253         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1254         iclockB += 4;
1255       }
1256 void BOp9B(void)  // ADDA DP
1257 {
1258   tmp = RdMemB((dprB<<8)|FetchB());
1259   addr = (WORD)arB + (WORD)tmp;
1260   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1261   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1262   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1263   arB = addr & 0xFF;                       // Set accumulator
1264   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1265   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1266   iclockB += 4;
1267 }
1268 void BOp9C(void)  // CMPX DP
1269       {
1270         addr = (dprB<<8)|FetchB();
1271         WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1272         WORD dw = xrB - adr2;
1273         (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1274         (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1275         (xrB < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1276         ((xrB^adr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
1277         iclockB += 6;
1278       }
1279 void BOp9D(void)  // JSR DP
1280       {
1281         addr = (dprB<<8) | FetchB();
1282         WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);
1283         pcrB = addr;      // JSR to DP location...
1284         iclockB += 7;
1285       }
1286 void BOp9E(void)  // LDX DP
1287       {
1288         addr = (dprB<<8) | FetchB();
1289         xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
1290         ccrB &= 0xFD;                              // CLV
1291         (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1292         (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1293         iclockB += 5;
1294       }
1295 void BOp9F(void)  // STX DP
1296       {
1297         addr = (dprB<<8) | FetchB();
1298         WrMemB(addr, xrB>>8);  WrMemB(addr+1, xrB&0xFF);
1299         ccrB &= 0xFD;                              // CLV
1300         (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1301         (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1302         iclockB += 5;
1303       }
1304 void BOpA0(void)  // SUBA IDX
1305       {
1306         tmp = RdMemB(DecodeIDXB(FetchB()));  BYTE as = arB;
1307         arB -= tmp;
1308         (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1309         (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1310         (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1311         ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1312         iclockB += 4;
1313       }
1314 void BOpA1(void)  // CMPA IDX
1315       {
1316         tmp = RdMemB(DecodeIDXB(FetchB()));
1317         BYTE db = arB - tmp;
1318         (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1319         (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1320         (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1321         ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1322         iclockB += 4;
1323       }
1324 void BOpA2(void)  // SBCA IDX
1325 {
1326   tmp = RdMemB(DecodeIDXB(FetchB()));  BYTE as = arB;
1327   arB = arB - tmp - (ccrB&0x01);
1328   (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1329   ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1330   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1331   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1332   iclockB += 4;
1333 }
1334 void BOpA3(void)  // SUBD IDX
1335 {
1336   addr = DecodeIDXB(FetchB());  WORD dr = (arB<<8)|brB, ds = dr;
1337   WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1338   dr -= adr2;
1339   (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1340   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1341   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1342   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1343   arB = dr>>8;  brB = dr&0xFF;
1344   iclockB += 6;
1345 }
1346 void BOpA4(void)  // ANDA IDX
1347       {
1348         arB &= RdMemB(DecodeIDXB(FetchB()));
1349         ccrB &= 0xFD;                            // Clear oVerflow flag
1350         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1351         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1352         iclockB += 4;
1353       }
1354 void BOpA5(void)  // BITA IDX
1355       {
1356         tmp = arB & RdMemB(DecodeIDXB(FetchB()));
1357         ccrB &= 0xFD;                             // Clear oVerflow flag
1358         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1359         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1360         iclockB += 4;
1361       }
1362 void BOpA6(void)  // LDA IDX
1363 {
1364   arB = RdMemB(DecodeIDXB(FetchB()));
1365   ccrB &= 0xF1;                        // CLV CLZ CLN
1366   if (arB == 0)  ccrB |= 0x04;          // Set Zero flag
1367   if (arB&0x80)  ccrB |= 0x08;          // Set Negative flag
1368   iclockB += 4;
1369 }
1370 void BOpA7(void)  // STA IDX
1371 {
1372   WrMemB(DecodeIDXB(FetchB()), arB);
1373   ccrB &= 0xF1;                        // CLV CLZ CLN
1374   if (arB == 0)  ccrB |= 0x04;          // Set Zero flag
1375   if (arB&0x80)  ccrB |= 0x08;          // Set Negative flag
1376   iclockB += 4;
1377 }
1378 void BOpA8(void)  // EORA IDX
1379       {
1380         arB ^= RdMemB(DecodeIDXB(FetchB()));
1381         ccrB &= 0xFD;                            // CLV
1382         (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1383         (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1384         iclockB += 4;
1385       }
1386 void BOpA9(void)  // ADCA IDX
1387 {
1388   tmp = RdMemB(DecodeIDXB(FetchB()));
1389   addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
1390   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1391   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1392   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1393   arB = addr & 0xFF;                       // Set accumulator
1394   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1395   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1396   iclockB += 4;
1397 }
1398 void BOpAA(void)  // ORA IDX
1399 {
1400   arB |= RdMemB(DecodeIDXB(FetchB()));
1401   ccrB &= 0xFD;                            // CLV
1402   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1403   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1404   iclockB += 4;
1405 }
1406 void BOpAB(void)  // ADDA IDX
1407 {
1408   tmp = RdMemB(DecodeIDXB(FetchB()));
1409   addr = (WORD)arB + (WORD)tmp;
1410   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1411   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1412   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1413   arB = addr & 0xFF;                       // Set accumulator
1414   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1415   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1416   iclockB += 4;
1417 }
1418 void BOpAC(void)  // CMPX IDX
1419 {
1420   addr = DecodeIDXB(FetchB());
1421   WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1422   WORD dw = xrB - addr2;
1423   (dw == 0    ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1424   (dw&0x8000  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1425   (xrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1426   ((xrB^addr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1427   iclockB += 6;
1428 }
1429 void BOpAD(void)  // JSR IDX
1430 {
1431   addr = DecodeIDXB(FetchB());
1432   WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);
1433   pcrB = addr;                               // JSR directly to IDX ptr
1434   iclockB += 7;
1435 }
1436 void BOpAE(void)  // LDX IDX
1437 {
1438   addr = DecodeIDXB(FetchB());
1439   xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
1440   ccrB &= 0xFD;                              // CLV
1441   (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1442   (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1443   iclockB += 5;
1444 }
1445 void BOpAF(void)  // STX IDX
1446 {
1447   addr = DecodeIDXB(FetchB());
1448   WrMemB(addr, xrB>>8);  WrMemB(addr+1, xrB&0xFF);
1449   ccrB &= 0xF1;                              // CLV CLZ CLN
1450   if (xrB == 0)    ccrB |= 0x04;              // Set Zero flag
1451   if (xrB&0x8000)  ccrB |= 0x08;              // Set Negative flag
1452   iclockB += 5;
1453 }
1454 void BOpB0(void)  // SUBA ABS
1455       {
1456         tmp = RdMemB(FetchWB());  BYTE as = arB;
1457         arB -= tmp;
1458         (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1459         (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1460         (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1461         ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1462         iclockB += 5;
1463       }
1464 void BOpB1(void)  // CMPA ABS
1465       {
1466         tmp = RdMemB(FetchWB());
1467         BYTE db = arB - tmp;
1468         (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1469         (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1470         (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1471         ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1472         iclockB += 5;
1473       }
1474 void BOpB2(void)  // SBCA ABS
1475 {
1476   tmp = RdMemB(FetchWB());  BYTE as = arB;
1477   arB = arB - tmp - (ccrB&0x01);
1478   (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1479   ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1480   (arB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1481   (arB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1482   iclockB += 5;
1483 }
1484 void BOpB3(void)  // SUBD ABS
1485 {
1486   addr = FetchWB();  WORD dr = (arB<<8)|brB, ds = dr;
1487   WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1488   dr -= adr2;
1489   (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1490   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
1491   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1492   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1493   arB = dr>>8;  brB = dr&0xFF;
1494   iclockB += 7;
1495 }
1496 void BOpB4(void)  // ANDA ABS
1497 {
1498   arB &= RdMemB(FetchWB());
1499   ccrB &= 0xFD;                            // Clear oVerflow flag
1500   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1501   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1502   iclockB += 5;
1503 }
1504 void BOpB5(void)  // BITA ABS
1505 {
1506   tmp = arB & RdMemB(FetchWB());
1507   ccrB &= 0xFD;                             // Clear oVerflow flag
1508   (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1509   (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1510   iclockB += 5;
1511 }
1512 void BOpB6(void)  // LDA ABS
1513 {
1514   arB = RdMemB(FetchWB());
1515   ccrB &= 0xFD;                            // CLV
1516   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1517   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1518   iclockB += 5;
1519 }
1520 void BOpB7(void)  // STA ABS
1521 {
1522   WrMemB(FetchWB(), arB);
1523   ccrB &= 0xFD;                            // CLV
1524   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1525   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1526   iclockB += 5;
1527 }
1528 void BOpB8(void)  // EORA ABS
1529 {
1530   arB ^= RdMemB(FetchWB());
1531   ccrB &= 0xFD;                            // CLV
1532   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1533   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1534   iclockB += 5;
1535 }
1536 void BOpB9(void)  // ADCA ABS
1537 {
1538   tmp = RdMemB(FetchWB());
1539   addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
1540   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1541   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1542   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1543   arB = addr;                              // Set accumulator
1544   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1545   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1546   iclockB += 5;
1547 }
1548 void BOpBA(void)  // ORA ABS
1549 {
1550   arB |= RdMemB(FetchWB());
1551   ccrB &= 0xFD;                            // CLV
1552   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1553   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1554   iclockB += 5;
1555 }
1556 void BOpBB(void)  // ADDA ABS
1557 {
1558   tmp = RdMemB(FetchWB());
1559   addr = (WORD)arB + (WORD)tmp;
1560   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1561   ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1562   ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1563   arB = addr & 0xFF;                       // Set accumulator
1564   (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1565   (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1566   iclockB += 5;
1567 }
1568 void BOpBC(void)  // CMPX ABS
1569 {
1570   addr = FetchWB();  WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
1571   WORD dw = xrB - addr2;
1572   (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1573   (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1574   (xrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1575   ((xrB^addr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1576   iclockB += 7;
1577 }
1578 void BOpBD(void)  // JSR ABS
1579 {
1580   addr = FetchWB();
1581   WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);
1582   pcrB = addr;                          // Go to absolute address (Not indir)
1583   iclockB += 8;
1584 }
1585 void BOpBE(void)  // LDX ABS
1586 {
1587   addr = FetchWB();
1588   xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
1589   ccrB &= 0xFD;                              // CLV
1590   (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1591   (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1592   iclockB += 6;
1593 }
1594 void BOpBF(void)  // STX ABS
1595       {
1596         addr = FetchWB();
1597         WrMemB(addr, xrB>>8);  WrMemB(addr+1, xrB&0xFF);
1598         ccrB &= 0xFD;                              // CLV
1599         (xrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1600         (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1601         iclockB += 6;
1602       }
1603 void BOpC0(void)  // SUBB #
1604       {
1605         tmp = FetchB();  BYTE bs = brB;
1606         brB -= tmp;
1607         (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1608         (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1609         (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1610         ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1611         iclockB += 2;
1612       }
1613 void BOpC1(void)  // CMPB #
1614       {
1615         tmp = FetchB();
1616         BYTE db = brB - tmp;
1617         (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1618         ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1619         (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1620         (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1621         iclockB += 2;
1622       }
1623 void BOpC2(void)  // SBCB #
1624 {
1625   tmp = FetchB();  BYTE bs = brB;
1626   brB = brB - tmp - (ccrB&0x01);
1627   (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1628   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1629   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1630   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1631   iclockB += 2;
1632 }
1633 void BOpC3(void)  // ADDD #
1634 {
1635   addr = FetchWB();  long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
1636   dr += addr;
1637   (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1638   dr &= 0xFFFF;
1639   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1640   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1641   ((ds^addr^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
1642   arB = dr>>8;  brB = dr&0xFF;
1643   iclockB += 4;
1644 }
1645 void BOpC4(void)  // ANDB #
1646       {
1647         brB &= FetchB();
1648         ccrB &= 0xFD;                            // Clear oVerflow flag
1649         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1650         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1651         iclockB += 2;
1652       }
1653 void BOpC5(void)  // BITB #
1654 {
1655   tmp = brB & FetchB();
1656   ccrB &= 0xF1;                             // CLV CLZ CLN
1657   if (tmp == 0)  ccrB |= 0x04;              // Set Zero flag
1658   if (tmp&0x80)  ccrB |= 0x08;              // Set Negative flag
1659   iclockB += 2;
1660 }
1661 void BOpC6(void)  // LDB #
1662 {
1663   brB = FetchB();
1664   ccrB &= 0xF1;                             // CLV CLZ CLN
1665   if (brB == 0)  ccrB |= 0x04;               // Set Zero flag
1666   if (brB&0x80)  ccrB |= 0x08;               // Set Negative flag
1667   iclockB += 2;
1668 }
1669 void BOpC8(void)  // EORB #
1670       {
1671         brB ^= FetchB();
1672         ccrB &= 0xFD;                            // CLV
1673         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1674         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1675         iclockB += 2;
1676       }
1677 void BOpC9(void)  // ADCB #
1678 {
1679   tmp = FetchB();
1680   addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
1681   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1682   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1683   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1684   brB = addr & 0xFF;                       // Set accumulator
1685   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1686   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1687   iclockB += 2;
1688 }
1689 void BOpCA(void)  // ORB #
1690       {
1691         brB |= FetchB();
1692         ccrB &= 0xFD;                            // CLV
1693         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1694         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1695         iclockB += 2;
1696       }
1697 void BOpCB(void)  // ADDB #
1698 {
1699   tmp = FetchB();  addr = brB + tmp;
1700   (addr > 0xFF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1701   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1702   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
1703   brB = addr & 0xFF;                       // Set accumulator
1704   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1705   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1706   iclockB += 2;
1707 }
1708 void BOpCC(void)  // LDD #
1709 {
1710   arB = FetchB();  brB = FetchB();
1711   ccrB &= 0xFD;                                 // CLV
1712   ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1713   (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1714   iclockB += 3;
1715 }
1716 void BOpCE(void)  // LDU #
1717 {
1718   urB = FetchWB();
1719   ccrB &= 0xFD;                              // CLV
1720   (urB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1721   (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1722   iclockB += 3;
1723 }
1724 void BOpD0(void)  // SUBB DP
1725 {
1726   tmp = RdMemB((dprB<<8)|FetchB());  BYTE bs = brB;
1727   brB -= tmp;
1728   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1729   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1730   (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1731   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1732   iclockB += 4;
1733 }
1734 void BOpD1(void)  // CMPB DP
1735 {
1736   tmp = RdMemB((dprB<<8)|FetchB());
1737   BYTE db = brB - tmp;
1738   (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1739   (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1740   (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1741   ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1742   iclockB += 4;
1743 }
1744 void BOpD2(void)  // SBCB DP
1745 {
1746   tmp = RdMemB((dprB<<8)|FetchB());  BYTE bs = brB;
1747   brB = brB - tmp - (ccrB&0x01);
1748   (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1749   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1750   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1751   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1752   iclockB += 4;
1753 }
1754 void BOpD3(void)  // ADDD DP
1755 {
1756   addr = (dprB<<8)|FetchB();  long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
1757   WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
1758   dr += adr2;
1759   (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1760   dr &= 0xFFFF;
1761   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1762   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1763   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1764   arB = dr>>8;  brB = dr&0xFF;
1765   iclockB += 6;
1766 }
1767 void BOpD4(void)  // ANDB DP
1768       {
1769         brB &= RdMemB((dprB<<8)|FetchB());
1770         ccrB &= 0xFD;                            // Clear oVerflow flag
1771         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1772         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1773         iclockB += 4;
1774       }
1775 void BOpD5(void)  // BITB DP
1776       {
1777         tmp = brB & RdMemB((dprB<<8)|FetchB());
1778         ccrB &= 0xFD;                             // Clear oVerflow flag
1779         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1780         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1781         iclockB += 4;
1782       }
1783 void BOpD6(void)  // LDB DP
1784 {
1785   brB = RdMemB((dprB<<8)|FetchB());
1786   ccrB &= 0xFD;                            // CLV
1787   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1788   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1789   iclockB += 4;
1790 }
1791 void BOpD7(void)  // STB DP
1792       {
1793         WrMemB((dprB<<8)|FetchB(), brB);
1794         ccrB &= 0xFD;                            // CLV
1795         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1796         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1797         iclockB += 4;
1798       }
1799 void BOpD8(void)  // EORB DP
1800       {
1801         brB ^= RdMemB((dprB<<8)|FetchB());
1802         ccrB &= 0xFD;                            // CLV
1803         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1804         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1805         iclockB += 4;
1806       }
1807 void BOpD9(void)  // ADCB DP
1808 {
1809   tmp = RdMemB((dprB<<8)|FetchB());
1810   addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
1811   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1812   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1813   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1814   brB = addr;                              // Set accumulator
1815   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1816   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1817   iclockB += 4;
1818 }
1819 void BOpDA(void)  // ORB DP
1820       {
1821         brB |= RdMemB((dprB<<8)|FetchB());
1822         ccrB &= 0xFD;                            // CLV
1823         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1824         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1825         iclockB += 4;
1826       }
1827 void BOpDB(void)  // ADDB DP
1828 {
1829   tmp = RdMemB((dprB<<8)|FetchB());
1830   addr = (WORD)brB + (WORD)tmp;
1831   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1832   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1833   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1834   brB = addr & 0xFF;                       // Set accumulator
1835   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1836   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1837   iclockB += 4;
1838 }
1839 void BOpDC(void)  // LDD DP
1840 {
1841   addr = (dprB<<8)|FetchB();
1842   arB = RdMemB(addr);  brB = RdMemB(addr+1);
1843   ccrB &= 0xFD;                                 // CLV
1844   ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1845   (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1846   iclockB += 5;
1847 }
1848 void BOpDD(void)  // STD DP
1849 {
1850   addr = (dprB<<8)|FetchB();
1851   WrMemB(addr, arB);  WrMemB(addr+1, brB);
1852   ccrB &= 0xFD;                                 // CLV
1853   ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1854   (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1855   iclockB += 5;
1856 }
1857 void BOpDE(void)  // LDU DP
1858 {
1859   addr = (dprB<<8)|FetchB();
1860   urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
1861   ccrB &= 0xFD;                              // CLV
1862   (urB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1863   (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1864   iclockB += 5;
1865 }
1866 void BOpDF(void)  // STU DP
1867 {
1868   addr = (dprB<<8)|FetchB();
1869   WrMemB(addr, urB>>8);  WrMemB(addr+1, urB&0xFF);
1870   ccrB &= 0xFD;                              // CLV
1871   (urB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1872   (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1873   iclockB += 5;
1874 }
1875 void BOpE0(void)  // SUBB IDX
1876 {
1877   tmp = RdMemB(DecodeIDXB(FetchB()));  BYTE bs = brB;
1878   brB -= tmp;
1879   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1880   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1881   (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1882   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1883   iclockB += 4;
1884 }
1885 void BOpE1(void)  // CMPB IDX
1886 {
1887   tmp = RdMemB(DecodeIDXB(FetchB()));
1888   BYTE db = brB - tmp;
1889   (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1890   (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1891   (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1892   ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1893   iclockB += 4;
1894 }
1895 void BOpE2(void)  // SBCB IDX
1896 {
1897   tmp = RdMemB(DecodeIDXB(FetchB()));  BYTE bs = brB;
1898   brB = brB - tmp - (ccrB&0x01);
1899   (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1900   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1901   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1902   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1903   iclockB += 4;
1904 }
1905 void BOpE3(void)  // ADDD IDX
1906 {
1907   addr = DecodeIDXB(FetchB());  long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
1908   WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
1909   dr += adr2;
1910   (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
1911   dr &= 0xFFFF;
1912   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1913   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1914   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1915   arB = dr>>8;  brB = dr&0xFF;
1916   iclockB += 6;
1917 }
1918 void BOpE4(void)  // ANDB IDX
1919       {
1920         brB &= RdMemB(DecodeIDXB(FetchB()));
1921         ccrB &= 0xFD;                            // Clear oVerflow flag
1922         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1923         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1924         iclockB += 4;
1925       }
1926 void BOpE5(void)  // BITB IDX
1927       {
1928         tmp = brB & RdMemB(DecodeIDXB(FetchB()));
1929         ccrB &= 0xFD;                             // Clear oVerflow flag
1930         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1931         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1932         iclockB += 4;
1933       }
1934 void BOpE6(void)  // LDB IDX
1935       {
1936         brB = RdMemB(DecodeIDXB(FetchB()));
1937         ccrB &= 0xFD;                            // CLV
1938         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1939         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1940         iclockB += 4;
1941       }
1942 void BOpE7(void)  // STB IDX
1943 {
1944   WrMemB(DecodeIDXB(FetchB()), brB);
1945   ccrB &= 0xF1;                            // CLV CLZ CLN
1946   if (brB == 0)  ccrB |= 0x04;              // Adjust Zero flag
1947   if (brB&0x80)  ccrB |= 0x08;              // Adjust Negative flag
1948   iclockB += 4;
1949 }
1950 void BOpE8(void)  // EORB IDX
1951       {
1952         brB ^= RdMemB(DecodeIDXB(FetchB()));
1953         ccrB &= 0xFD;                            // CLV
1954         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1955         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1956         iclockB += 4;
1957       }
1958 void BOpE9(void)  // ADCB IDX
1959 {
1960   tmp = RdMemB(DecodeIDXB(FetchB()));
1961   addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
1962   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1963   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1964   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1965   brB = addr;                              // Set accumulator
1966   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1967   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1968   iclockB += 4;
1969 }
1970 void BOpEA(void)  // ORB IDX
1971       {
1972         brB |= RdMemB(DecodeIDXB(FetchB()));
1973         ccrB &= 0xFD;                            // CLV
1974         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
1975         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
1976         iclockB += 4;
1977       }
1978 void BOpEB(void)  // ADDB IDX
1979 {
1980   tmp = RdMemB(DecodeIDXB(FetchB()));
1981   addr = (WORD)brB + (WORD)tmp;
1982   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
1983   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
1984   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
1985   brB = addr;                              // Set accumulator
1986   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
1987   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
1988   iclockB += 4;
1989 }
1990 void BOpEC(void)  // LDD IDX
1991 {
1992   addr = DecodeIDXB(FetchB());
1993   arB = RdMemB(addr);  brB = RdMemB(addr+1);
1994   ccrB &= 0xF1;                             // CLV CLZ CLN
1995   if (!(arB|brB))  ccrB |= 0x04;              // Adjust Zero flag
1996   if (arB&0x80)   ccrB |= 0x08;              // Adjust Negative flag
1997   iclockB += 5;
1998 }
1999 void BOpED(void)  // STD IDX
2000 {
2001   addr = DecodeIDXB(FetchB());
2002   WrMemB(addr, arB);  WrMemB(addr+1, brB);
2003   ccrB &= 0xF1;                             // CLV CLZ CLZ
2004   if (!(arB|brB))  ccrB |= 0x04;              // Adjust Zero flag
2005   if (arB&0x80)   ccrB |= 0x08;              // Adjust Negative flag
2006   iclockB += 5;
2007 }
2008 void BOpEE(void)  // LDU IDX
2009 {
2010   addr = DecodeIDXB(FetchB());
2011   urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
2012   ccrB &= 0xF1;                              // CLV CLZ CLN
2013   if (urB == 0)    ccrB |= 0x04;              // Set Zero flag
2014   if (urB&0x8000)  ccrB |= 0x08;              // Set Negative flag
2015   iclockB += 5;
2016 }
2017 void BOpEF(void)  // STU IDX
2018 {
2019   addr = DecodeIDXB(FetchB());
2020   WrMemB(addr, urB>>8);  WrMemB(addr+1, urB&0xFF);
2021   ccrB &= 0xF1;                              // CLV CLZ CLN
2022   if (urB == 0)    ccrB |= 0x04;              // Set Zero flag
2023   if (urB&0x8000)  ccrB |= 0x08;              // Set Negative flag
2024   iclockB += 5;
2025 }
2026 void BOpF0(void)  // SUBB ABS
2027       {
2028         tmp = RdMemB(FetchWB());  BYTE bs = brB;
2029         brB -= tmp;
2030         (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2031         (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2032         (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2033         ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
2034       }
2035 void BOpF1(void)  // CMPB ABS
2036       {
2037         tmp = RdMemB(FetchWB());
2038         BYTE db = brB - tmp;
2039         (db == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2040         (db&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2041         (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2042         ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
2043         iclockB += 5;
2044       }
2045 void BOpF2(void)  // SBCB ABS
2046 {
2047   tmp = RdMemB(FetchWB());  BYTE bs = brB;
2048   brB = brB - tmp - (ccrB&0x01);
2049   (brB == 0  ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2050   (brB&0x80  ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2051   (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2052   ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
2053   iclockB += 5;
2054 }
2055 void BOpF3(void)  // ADDD ABS
2056 {
2057   addr = FetchWB();  long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
2058   WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
2059   dr += adr2;
2060   (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2061   dr &= 0xFFFF;
2062   (dr == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2063   (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2064   ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2065   arB = dr>>8;  brB = dr&0xFF;
2066   iclockB += 7;
2067 }
2068 void BOpF4(void)  // ANDB ABS
2069       {
2070         brB &= RdMemB(FetchWB());
2071         ccrB &= 0xFD;                            // Clear oVerflow flag
2072         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2073         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2074         iclockB += 5;
2075       }
2076 void BOpF5(void)  // BITB ABS
2077       {
2078         tmp = brB & RdMemB(FetchWB());
2079         ccrB &= 0xFD;                             // Clear oVerflow flag
2080         (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2081         (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2082         iclockB += 5;
2083       }
2084 void BOpF6(void)  // LDB ABS
2085       {
2086         brB = RdMemB(FetchWB());
2087         ccrB &= 0xFD;                            // CLV
2088         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2089         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2090         iclockB += 5;
2091       }
2092 void BOpF7(void)  // STB ABS
2093       {
2094         WrMemB(FetchWB(), brB);
2095         ccrB &= 0xFD;                            // CLV
2096         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2097         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2098         iclockB += 5;
2099       }
2100 void BOpF8(void)  // EORB ABS
2101       {
2102         brB ^= RdMemB(FetchWB());
2103         ccrB &= 0xFD;                            // CLV
2104         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2105         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2106         iclockB += 5;
2107       }
2108 void BOpF9(void)  // ADCB ABS
2109 {
2110   tmp = RdMemB(FetchWB());
2111   addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
2112   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
2113   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
2114   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
2115   brB = addr & 0xFF;                       // Set accumulator
2116   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
2117   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
2118   iclockB += 5;
2119 }
2120 void BOpFA(void)  // ORB ABS
2121       {
2122         brB |= RdMemB(FetchWB());
2123         ccrB &= 0xFD;                            // CLV
2124         (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2125         (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2126         iclockB += 5;
2127       }
2128 void BOpFB(void)  // ADDB ABS
2129 {
2130   tmp = RdMemB(FetchWB());
2131   addr = (WORD)brB + (WORD)tmp;
2132   (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE);  // Set Carry flag
2133   ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF);  // Set Half carry
2134   ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
2135   brB = addr & 0xFF;                       // Set accumulator
2136   (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Set Zero flag
2137   (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Set Negative flag
2138   iclockB += 5;
2139 }
2140 void BOpFC(void)  // LDD ABS
2141       {
2142         addr = FetchWB();
2143         arB = RdMemB(addr);  brB = RdMemB(addr+1);
2144         ccrB &= 0xFD;                                 // CLV
2145         ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2146         (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2147         iclockB += 6;
2148       }
2149 void BOpFD(void)  // STD ABS
2150       {
2151         addr = FetchWB();
2152         WrMemB(addr, arB);  WrMemB(addr+1, brB);
2153         ccrB &= 0xFD;                                 // CLV
2154         ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2155         (arB&0x80      ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2156         iclockB += 6;
2157       }
2158 void BOpFE(void)  // LDU ABS
2159       {
2160         addr = FetchWB();
2161         urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
2162         ccrB &= 0xFD;                              // CLV
2163         (urB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2164         (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2165         iclockB += 6;
2166       }
2167 void BOpFF(void)  // STU ABS
2168       {
2169         addr = FetchWB();
2170         WrMemB(addr, urB>>8);  WrMemB(addr+1, urB&0xFF);
2171         ccrB &= 0xFD;                              // CLV
2172         (urB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2173         (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2174         iclockB += 6;
2175       }
2176
2177 //
2178 // Page one opcodes' execute code
2179 //
2180
2181 void BOp1021(void)  // LBRN
2182 {
2183   addr = FetchWB();
2184   iclockB += 5;
2185 }
2186 void BOp1022(void)  // LBHI
2187 {
2188   addr = FetchWB();
2189   if (!((ccrB&0x01)|(ccrB&0x04)))  pcrB += SignedW(addr);
2190   iclockB += 5;
2191 }
2192 void BOp1023(void)  // LBLS
2193 {
2194   addr = FetchWB();
2195   if ((ccrB&0x01)|(ccrB&0x04))  pcrB += SignedW(addr);
2196   iclockB += 5;
2197 }
2198 void BOp1024(void)  // LBCC (LBHS)
2199 {
2200   addr = FetchWB();
2201   if (!(ccrB&0x01))  pcrB += SignedW(addr);
2202   iclockB += 5;
2203 }
2204 void BOp1025(void)  // LBCS (LBLO)
2205 {
2206   addr = FetchWB();
2207   if (ccrB&0x01)  pcrB += SignedW(addr);
2208   iclockB += 5;
2209 }
2210 void BOp1026(void)  // LBNE
2211 {
2212   addr = FetchWB();
2213   if (!(ccrB&0x04))  pcrB += SignedW(addr);
2214   iclockB += 5;
2215 }
2216 void BOp1027(void)  // LBEQ
2217 {
2218   addr = FetchWB();
2219   if (ccrB&0x04)  pcrB += SignedW(addr);
2220   iclockB += 5;
2221 }
2222 void BOp1028(void)  // LBVC
2223 {
2224   addr = FetchWB();
2225   if (!(ccrB&0x02))  pcrB += SignedW(addr);
2226   iclockB += 5;
2227 }
2228 void BOp1029(void)  // LBVS
2229 {
2230   addr = FetchWB();
2231   if (ccrB&0x02)  pcrB += SignedW(addr);
2232   iclockB += 5;
2233 }
2234 void BOp102A(void)  // LBPL
2235 {
2236   addr = FetchWB();
2237   if (!(ccrB&0x08))  pcrB += SignedW(addr);
2238   iclockB += 5;
2239 }
2240 void BOp102B(void)  // LBMI
2241 {
2242   addr = FetchWB();
2243   if (ccrB&0x08)  pcrB += SignedW(addr);
2244   iclockB += 5;
2245 }
2246 void BOp102C(void)  // LBGE
2247 {
2248   addr = FetchWB();
2249   if (!(((ccrB&0x08) >> 2) ^ (ccrB&0x02)))  pcrB += SignedW(addr);
2250   iclockB += 5;
2251 }
2252 void BOp102D(void)  // LBLT
2253 {
2254   addr = FetchWB();
2255   if (((ccrB&0x08) >> 2) ^ (ccrB&0x02))  pcrB += SignedW(addr);
2256   iclockB += 5;
2257 }
2258 void BOp102E(void)  // LBGT
2259 {
2260   addr = FetchWB();
2261   if (!((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02))))  pcrB += SignedW(addr);
2262   iclockB += 5;
2263 }
2264 void BOp102F(void)  // LBLE
2265 {
2266   addr = FetchWB();
2267   if ((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02))) pcrB += SignedW(addr);
2268   iclockB += 5;
2269 }
2270 void BOp103F(void)  // SWI2 (Not yet implemented)
2271 {
2272   iclockB += 20;
2273 }
2274 void BOp1083(void)  // CMPD #
2275     {
2276       addr = FetchWB();  WORD dr = (arB<<8)|brB;
2277       WORD dw = dr - addr;
2278       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2279       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2280       (dr < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2281       ((dr^addr^dw^((WORD)ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2282       iclockB += 5;
2283     }
2284 void BOp108C(void)  // CMPY #
2285     {
2286       addr = FetchWB();
2287       WORD dw = yrB - addr;
2288       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2289       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2290       (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2291       ((yrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2292       iclockB += 5;
2293     }
2294 void BOp108E(void)  // LDY #
2295     {
2296       yrB = FetchWB();
2297       ccrB &= 0xFD;                              // CLV
2298       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2299       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2300       iclockB += 4;
2301     }
2302 void BOp1093(void)  // CMPD DP
2303     {
2304       WORD adr2 = (dprB<<8)|FetchB(), dr = (arB<<8)|brB;
2305       addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2306       WORD dw = dr - addr;
2307       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2308       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2309       (dr < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2310       ((dr^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2311       iclockB += 7;
2312     }
2313 void BOp109C(void)  // CMPY DP
2314     {
2315       WORD adr2 = (dprB<<8)|FetchB();
2316       addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2317       WORD dw = yrB - addr;
2318       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2319       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2320       (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2321       ((yrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2322       iclockB += 7;
2323     }
2324 void BOp109E(void)  // LDY DP
2325     {
2326       addr = (dprB<<8)|FetchB();
2327       yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2328       ccrB &= 0xFD;                              // CLV
2329       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2330       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2331       iclockB += 6;
2332     }
2333 void BOp109F(void)  // STY DP
2334     {
2335       addr = (dprB<<8)|FetchB();
2336       WrMemB(addr, yrB>>8);  WrMemB(addr+1, yrB&0xFF);
2337       ccrB &= 0xFD;                              // CLV
2338       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2339       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2340       iclockB += 6;
2341     }
2342 void BOp10A3(void)  // CMPD IDX
2343 {
2344   WORD adr2 = DecodeIDXB(FetchB()), dr = (arB<<8)|brB;
2345   addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2346   WORD dw = dr - addr;
2347   ccrB &= 0xF0;                              // CLC CLV CLZ CLN
2348   if (dr < addr)  ccrB |= 0x01;              // Set Carry flag
2349   if ((dr^addr^dw^(ccrB<<15))&0x8000)  ccrB |= 0x02; // Set oVerflow
2350   if (dw == 0)    ccrB |= 0x04;              // Set Zero flag
2351   if (dw&0x8000)  ccrB |= 0x08;              // Set Negative flag
2352   iclockB += 7;
2353 }
2354 void BOp10AC(void)  // CMPY IDX
2355     {
2356       WORD adr2 = DecodeIDXB(FetchB());
2357       addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2358       WORD dw = yrB - addr;
2359       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2360       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2361       (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2362       (((ccrB<<15)^yrB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2363       iclockB += 7;
2364     }
2365 void BOp10AE(void)  // LDY IDX
2366 {
2367   addr = DecodeIDXB(FetchB());
2368   yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2369   ccrB &= 0xF1;                              // CLV CLZ CLN
2370   if (yrB == 0)    ccrB |= 0x04;              // Adjust Zero flag
2371   if (yrB&0x8000)  ccrB |= 0x08;              // Adjust Negative flag
2372   iclockB += 6;
2373 }
2374 void BOp10AF(void)  // STY IDX
2375     {
2376       addr = DecodeIDXB(FetchB());
2377       WrMemB(addr, yrB>>8);  WrMemB(addr+1, yrB&0xFF);
2378       ccrB &= 0xFD;                              // CLV
2379       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2380       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2381       iclockB += 6;
2382     }
2383 void BOp10B3(void)  // CMPD ABS
2384     {
2385       addr = FetchWB();  WORD dr = (arB<<8)|brB;
2386       WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
2387       WORD dw = dr - addr2;
2388       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2389       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2390       (dr < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2391       (((ccrB<<15)^dr^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2392       iclockB += 8;
2393     }
2394 void BOp10BC(void)  // CMPY ABS
2395     {
2396       addr = FetchWB();  WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
2397       WORD dw = yrB - addr2;
2398       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2399       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2400       (yrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2401       (((ccrB<<15)^yrB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2402       iclockB += 8;
2403     }
2404 void BOp10BE(void)  // LDY ABS
2405     {
2406       addr = FetchWB();
2407       yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2408       ccrB &= 0xFD;                              // CLV
2409       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2410       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2411       iclockB += 7;
2412     }
2413 void BOp10BF(void)  // STY ABS
2414     {
2415       addr = FetchWB();
2416       WrMemB(addr, yrB>>8);  WrMemB(addr+1, yrB&0xFF);
2417       ccrB &= 0xFD;                              // CLV
2418       (yrB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2419       (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2420       iclockB += 7;
2421     }
2422 void BOp10CE(void)  // LDS #
2423     {
2424       srB = FetchWB();
2425       ccrB &= 0xFD;                              // CLV
2426       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2427       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2428       iclockB += 4;
2429     }
2430 void BOp10DE(void)  // LDS DP
2431     {
2432       addr = (dprB<<8)|FetchB();
2433       srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2434       ccrB &= 0xFD;                              // CLV
2435       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2436       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2437       iclockB += 6;
2438     }
2439 void BOp10DF(void)  // STS DP
2440     {
2441       addr = (dprB<<8)|FetchB();
2442       WrMemB(addr, srB>>8);  WrMemB(addr+1, srB&0xFF);
2443       ccrB &= 0xFD;                              // CLV
2444       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2445       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2446       iclockB += 6;
2447     }
2448 void BOp10EE(void)  // LDS IDX
2449     {
2450       addr = DecodeIDXB(FetchB());
2451       srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2452       ccrB &= 0xFD;                              // CLV
2453       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2454       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2455       iclockB += 6;
2456     }
2457 void BOp10EF(void)  // STS IDX
2458     {
2459       addr = DecodeIDXB(FetchB());
2460       WrMemB(addr, srB>>8);  WrMemB(addr+1, srB&0xFF);
2461       ccrB &= 0xFD;                              // CLV
2462       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2463       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2464       iclockB += 6;
2465     }
2466 void BOp10FE(void)  // LDS ABS
2467     {
2468       addr = FetchWB();
2469       srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
2470       ccrB &= 0xFD;                              // CLV
2471       (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2472       (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2473       iclockB += 7;
2474     }
2475 void BOp10FF(void)  // STS ABS
2476 {
2477   addr = FetchWB();
2478   WrMemB(addr, srB>>8);  WrMemB(addr+1, srB&0xFF);
2479   ccrB &= 0xFD;                              // CLV
2480   (srB == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2481   (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2482   iclockB += 7;
2483 }
2484
2485 //
2486 // Page two opcodes' execute code
2487 //
2488
2489 void BOp113F(void)  // SWI3
2490     {
2491       iclockB += 20;
2492     }
2493 void BOp1183(void)  // CMPU #
2494     {
2495       addr = FetchWB();
2496       WORD dw = urB - addr;
2497       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2498       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2499       (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2500       (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2501       iclockB += 5;
2502     }
2503 void BOp118C(void)  // CMPS #
2504     {
2505       addr = FetchWB();
2506       WORD dw = srB - addr;
2507       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2508       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2509       (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2510       (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2511       iclockB += 5;
2512     }
2513 void BOp1193(void)  // CMPU DP
2514     {
2515       WORD adr2 = (dprB<<8)|FetchB();
2516       addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2517       WORD dw = urB - addr;
2518       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2519       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2520       (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2521       (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2522       iclockB += 7;
2523     }
2524 void BOp119C(void)  // CMPS DP
2525     {
2526       WORD adr2 = (dprB<<8)|FetchB();
2527       addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
2528       WORD dw = srB - addr;
2529       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2530       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2531       (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2532       (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2533       iclockB += 7;
2534     }
2535 void BOp11A3(void)  // CMPU IDX
2536     {
2537       WORD addr2 = DecodeIDXB(FetchB());
2538       addr = (RdMemB(addr2)<<8) | RdMemB(addr2+1);
2539       WORD dw = urB - addr;
2540       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2541       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2542       (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2543       (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2544       iclockB += 7;
2545     }
2546 void BOp11AC(void)  // CMPS IDX
2547     {
2548       WORD addr2 = DecodeIDXB(FetchB());
2549       addr = (RdMemB(addr2)<<8) | RdMemB(addr2+1);
2550       WORD dw = srB - addr;
2551       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2552       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2553       (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2554       (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2555       iclockB += 7;
2556     }
2557 void BOp11B3(void)  // CMPU ABS
2558     {
2559       addr = FetchWB();  WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
2560       WORD dw = urB - addr2;
2561       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2562       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2563       (urB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2564       (((ccrB<<15)^urB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2565       iclockB += 8;
2566     }
2567 void BOp11BC(void)  // CMPS ABS
2568     {
2569       addr = FetchWB();  WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
2570       WORD dw = srB - addr2;
2571       (dw == 0   ? ccrB |= 0x04 : ccrB &= 0xFB);  // Adjust Zero flag
2572       (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7);  // Adjust Negative flag
2573       (srB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE);  // Adjust Carry flag
2574       (((ccrB<<15)^srB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
2575       iclockB += 8;
2576     }
2577
2578 void IllegalBOp(void) { iclockB++;  illegalB = true; }
2579
2580 //
2581 // Initialize 6809 function adressess
2582 //
2583 void Init_6809B(void)
2584 {
2585   for(int i=0; i<256; i++)          // Set all functions to illegal
2586   {
2587     exec_op0B[i] = IllegalBOp;
2588     exec_op1B[i] = IllegalBOp;
2589     exec_op2B[i] = IllegalBOp;
2590   }
2591   exec_op0B[0x00] = BOp00;  exec_op0B[0x03] = BOp03;  exec_op0B[0x04] = BOp04;
2592   exec_op0B[0x06] = BOp06;  exec_op0B[0x07] = BOp07;  exec_op0B[0x08] = BOp08;
2593   exec_op0B[0x09] = BOp09;  exec_op0B[0x0A] = BOp0A;  exec_op0B[0x0C] = BOp0C;
2594   exec_op0B[0x0D] = BOp0D;  exec_op0B[0x0E] = BOp0E;  exec_op0B[0x0F] = BOp0F;
2595   exec_op0B[0x12] = BOp12;  exec_op0B[0x13] = BOp13;  exec_op0B[0x16] = BOp16;
2596   exec_op0B[0x17] = BOp17;  exec_op0B[0x19] = BOp19;  exec_op0B[0x1A] = BOp1A;
2597   exec_op0B[0x1C] = BOp1C;  exec_op0B[0x1D] = BOp1D;  exec_op0B[0x1E] = BOp1E;
2598   exec_op0B[0x1F] = BOp1F;  exec_op0B[0x20] = BOp20;  exec_op0B[0x21] = BOp21;
2599   exec_op0B[0x22] = BOp22;  exec_op0B[0x23] = BOp23;  exec_op0B[0x24] = BOp24;
2600   exec_op0B[0x25] = BOp25;  exec_op0B[0x26] = BOp26;  exec_op0B[0x27] = BOp27;
2601   exec_op0B[0x28] = BOp28;  exec_op0B[0x29] = BOp29;  exec_op0B[0x2A] = BOp2A;
2602   exec_op0B[0x2B] = BOp2B;  exec_op0B[0x2C] = BOp2C;  exec_op0B[0x2D] = BOp2D;
2603   exec_op0B[0x2E] = BOp2E;  exec_op0B[0x2F] = BOp2F;  exec_op0B[0x30] = BOp30;
2604   exec_op0B[0x31] = BOp31;  exec_op0B[0x32] = BOp32;  exec_op0B[0x33] = BOp33;
2605   exec_op0B[0x34] = BOp34;  exec_op0B[0x35] = BOp35;  exec_op0B[0x36] = BOp36;
2606   exec_op0B[0x37] = BOp37;  exec_op0B[0x39] = BOp39;  exec_op0B[0x3A] = BOp3A;
2607   exec_op0B[0x3B] = BOp3B;  exec_op0B[0x3C] = BOp3C;  exec_op0B[0x3D] = BOp3D;
2608   exec_op0B[0x3E] = BOp3E;  exec_op0B[0x3F] = BOp3F;  exec_op0B[0x40] = BOp40;
2609   exec_op0B[0x43] = BOp43;  exec_op0B[0x44] = BOp44;  exec_op0B[0x46] = BOp46;
2610   exec_op0B[0x47] = BOp47;  exec_op0B[0x48] = BOp48;  exec_op0B[0x49] = BOp49;
2611   exec_op0B[0x4A] = BOp4A;  exec_op0B[0x4C] = BOp4C;  exec_op0B[0x4D] = BOp4D;
2612   exec_op0B[0x4F] = BOp4F;  exec_op0B[0x50] = BOp50;  exec_op0B[0x53] = BOp53;
2613   exec_op0B[0x54] = BOp54;  exec_op0B[0x56] = BOp56;  exec_op0B[0x57] = BOp57;
2614   exec_op0B[0x58] = BOp58;  exec_op0B[0x59] = BOp59;  exec_op0B[0x5A] = BOp5A;
2615   exec_op0B[0x5C] = BOp5C;  exec_op0B[0x5D] = BOp5D;  exec_op0B[0x5F] = BOp5F;
2616   exec_op0B[0x60] = BOp60;  exec_op0B[0x63] = BOp63;  exec_op0B[0x64] = BOp64;
2617   exec_op0B[0x66] = BOp66;  exec_op0B[0x67] = BOp67;  exec_op0B[0x68] = BOp68;
2618   exec_op0B[0x69] = BOp69;  exec_op0B[0x6A] = BOp6A;  exec_op0B[0x6C] = BOp6C;
2619   exec_op0B[0x6D] = BOp6D;  exec_op0B[0x6E] = BOp6E;  exec_op0B[0x6F] = BOp6F;
2620   exec_op0B[0x70] = BOp70;  exec_op0B[0x73] = BOp73;  exec_op0B[0x74] = BOp74;
2621   exec_op0B[0x76] = BOp76;  exec_op0B[0x77] = BOp77;  exec_op0B[0x78] = BOp78;
2622   exec_op0B[0x79] = BOp79;  exec_op0B[0x7A] = BOp7A;  exec_op0B[0x7C] = BOp7C;
2623   exec_op0B[0x7D] = BOp7D;  exec_op0B[0x7E] = BOp7E;  exec_op0B[0x7F] = BOp7F;
2624   exec_op0B[0x80] = BOp80;  exec_op0B[0x81] = BOp81;  exec_op0B[0x82] = BOp82;
2625   exec_op0B[0x83] = BOp83;  exec_op0B[0x84] = BOp84;  exec_op0B[0x85] = BOp85;
2626   exec_op0B[0x86] = BOp86;  exec_op0B[0x88] = BOp88;  exec_op0B[0x89] = BOp89;
2627   exec_op0B[0x8A] = BOp8A;  exec_op0B[0x8B] = BOp8B;  exec_op0B[0x8C] = BOp8C;
2628   exec_op0B[0x8D] = BOp8D;  exec_op0B[0x8E] = BOp8E;  exec_op0B[0x90] = BOp90;
2629   exec_op0B[0x91] = BOp91;  exec_op0B[0x92] = BOp92;  exec_op0B[0x93] = BOp93;
2630   exec_op0B[0x94] = BOp94;  exec_op0B[0x95] = BOp95;  exec_op0B[0x96] = BOp96;
2631   exec_op0B[0x97] = BOp97;  exec_op0B[0x98] = BOp98;  exec_op0B[0x99] = BOp99;
2632   exec_op0B[0x9A] = BOp9A;  exec_op0B[0x9B] = BOp9B;  exec_op0B[0x9C] = BOp9C;
2633   exec_op0B[0x9D] = BOp9D;  exec_op0B[0x9E] = BOp9E;  exec_op0B[0x9F] = BOp9F;
2634   exec_op0B[0xA0] = BOpA0;  exec_op0B[0xA1] = BOpA1;  exec_op0B[0xA2] = BOpA2;
2635   exec_op0B[0xA3] = BOpA3;  exec_op0B[0xA4] = BOpA4;  exec_op0B[0xA5] = BOpA5;
2636   exec_op0B[0xA6] = BOpA6;  exec_op0B[0xA7] = BOpA7;  exec_op0B[0xA8] = BOpA8;
2637   exec_op0B[0xA9] = BOpA9;  exec_op0B[0xAA] = BOpAA;  exec_op0B[0xAB] = BOpAB;
2638   exec_op0B[0xAC] = BOpAC;  exec_op0B[0xAD] = BOpAD;  exec_op0B[0xAE] = BOpAE;
2639   exec_op0B[0xAF] = BOpAF;  exec_op0B[0xB0] = BOpB0;  exec_op0B[0xB1] = BOpB1;
2640   exec_op0B[0xB2] = BOpB2;  exec_op0B[0xB3] = BOpB3;  exec_op0B[0xB4] = BOpB4;
2641   exec_op0B[0xB5] = BOpB5;  exec_op0B[0xB6] = BOpB6;  exec_op0B[0xB7] = BOpB7;
2642   exec_op0B[0xB8] = BOpB8;  exec_op0B[0xB9] = BOpB9;  exec_op0B[0xBA] = BOpBA;
2643   exec_op0B[0xBB] = BOpBB;  exec_op0B[0xBC] = BOpBC;  exec_op0B[0xBD] = BOpBD;
2644   exec_op0B[0xBE] = BOpBE;  exec_op0B[0xBF] = BOpBF;  exec_op0B[0xC0] = BOpC0;
2645   exec_op0B[0xC1] = BOpC1;  exec_op0B[0xC2] = BOpC2;  exec_op0B[0xC3] = BOpC3;
2646   exec_op0B[0xC4] = BOpC4;  exec_op0B[0xC5] = BOpC5;  exec_op0B[0xC6] = BOpC6;
2647   exec_op0B[0xC8] = BOpC8;  exec_op0B[0xC9] = BOpC9;  exec_op0B[0xCA] = BOpCA;
2648   exec_op0B[0xCB] = BOpCB;  exec_op0B[0xCC] = BOpCC;
2649   exec_op0B[0xCE] = BOpCE;  exec_op0B[0xD0] = BOpD0;  exec_op0B[0xD1] = BOpD1;
2650   exec_op0B[0xD2] = BOpD2;  exec_op0B[0xD3] = BOpD3;  exec_op0B[0xD4] = BOpD4;
2651   exec_op0B[0xD5] = BOpD5;  exec_op0B[0xD6] = BOpD6;  exec_op0B[0xD7] = BOpD7;
2652   exec_op0B[0xD8] = BOpD8;  exec_op0B[0xD9] = BOpD9;  exec_op0B[0xDA] = BOpDA;
2653   exec_op0B[0xDB] = BOpDB;  exec_op0B[0xDC] = BOpDC;  exec_op0B[0xDD] = BOpDD;
2654   exec_op0B[0xDE] = BOpDE;  exec_op0B[0xDF] = BOpDF;  exec_op0B[0xE0] = BOpE0;
2655   exec_op0B[0xE1] = BOpE1;  exec_op0B[0xE2] = BOpE2;  exec_op0B[0xE3] = BOpE3;
2656   exec_op0B[0xE4] = BOpE4;  exec_op0B[0xE5] = BOpE5;  exec_op0B[0xE6] = BOpE6;
2657   exec_op0B[0xE7] = BOpE7;  exec_op0B[0xE8] = BOpE8;  exec_op0B[0xE9] = BOpE9;
2658   exec_op0B[0xEA] = BOpEA;  exec_op0B[0xEB] = BOpEB;  exec_op0B[0xEC] = BOpEC;
2659   exec_op0B[0xED] = BOpED;  exec_op0B[0xEE] = BOpEE;  exec_op0B[0xEF] = BOpEF;
2660   exec_op0B[0xF0] = BOpF0;
2661   exec_op0B[0xF1] = BOpF1;  exec_op0B[0xF2] = BOpF2;  exec_op0B[0xF3] = BOpF3;
2662   exec_op0B[0xF4] = BOpF4;  exec_op0B[0xF5] = BOpF5;  exec_op0B[0xF6] = BOpF6;
2663   exec_op0B[0xF7] = BOpF7;  exec_op0B[0xF8] = BOpF8;  exec_op0B[0xF9] = BOpF9;
2664   exec_op0B[0xFA] = BOpFA;  exec_op0B[0xFB] = BOpFB;  exec_op0B[0xFC] = BOpFC;
2665   exec_op0B[0xFD] = BOpFD;  exec_op0B[0xFE] = BOpFE;  exec_op0B[0xFF] = BOpFF;
2666
2667   exec_op1B[0x21] = BOp1021; exec_op1B[0x22] = BOp1022; exec_op1B[0x23] = BOp1023;
2668   exec_op1B[0x24] = BOp1024; exec_op1B[0x25] = BOp1025; exec_op1B[0x26] = BOp1026;
2669   exec_op1B[0x27] = BOp1027; exec_op1B[0x28] = BOp1028; exec_op1B[0x29] = BOp1029;
2670   exec_op1B[0x2A] = BOp102A; exec_op1B[0x2B] = BOp102B; exec_op1B[0x2C] = BOp102C;
2671   exec_op1B[0x2D] = BOp102D; exec_op1B[0x2E] = BOp102E; exec_op1B[0x2F] = BOp102F;
2672   exec_op1B[0x3F] = BOp103F; exec_op1B[0x83] = BOp1083; exec_op1B[0x8C] = BOp108C;
2673   exec_op1B[0x8E] = BOp108E; exec_op1B[0x93] = BOp1093; exec_op1B[0x9C] = BOp109C;
2674   exec_op1B[0x9E] = BOp109E; exec_op1B[0x9F] = BOp109F; exec_op1B[0xA3] = BOp10A3;
2675   exec_op1B[0xAC] = BOp10AC; exec_op1B[0xAE] = BOp10AE; exec_op1B[0xAF] = BOp10AF;
2676   exec_op1B[0xB3] = BOp10B3; exec_op1B[0xBC] = BOp10BC; exec_op1B[0xBE] = BOp10BE;
2677   exec_op1B[0xBF] = BOp10BF; exec_op1B[0xCE] = BOp10CE; exec_op1B[0xDE] = BOp10DE;
2678   exec_op1B[0xDF] = BOp10DF; exec_op1B[0xEE] = BOp10EE; exec_op1B[0xEF] = BOp10EF;
2679   exec_op1B[0xFE] = BOp10FE; exec_op1B[0xFF] = BOp10FF;
2680
2681   exec_op2B[0x3F] = BOp113F; exec_op2B[0x83] = BOp1183; exec_op2B[0x8C] = BOp118C;
2682   exec_op2B[0x93] = BOp1193; exec_op2B[0x9C] = BOp119C; exec_op2B[0xA3] = BOp11A3;
2683   exec_op2B[0xAC] = BOp11AC; exec_op2B[0xB3] = BOp11B3; exec_op2B[0xBC] = BOp11BC;
2684 }
2685
2686 //
2687 // Function to execute one 6809 instruction
2688 //
2689 void Execute_6809B(long num_of_instrs_to_exec)
2690 {
2691   for(long i=0; i<num_of_instrs_to_exec; i++)
2692   {
2693     BYTE opcode = FetchB();                                 // Get the opcode
2694     if (opcode == 0x10)  { exec_op1B[FetchB()]();  goto EXE_NEXT; }
2695     if (opcode == 0x11)  { exec_op2B[FetchB()]();  goto EXE_NEXT; }
2696     exec_op0B[opcode]();
2697     EXE_NEXT:
2698
2699     if (iclockB > 24550)  // Slightly faster IRQs for SUB processor
2700     {
2701       iclockB = 0;
2702       if (!(ccrB&0x10) /*&& (!inter)*/)      // Process an interrupt?
2703       {
2704         ccrB |= 0x80;        // Set E
2705         WrMemB(--srB, pcrB&0xFF);  WrMemB(--srB, pcrB>>8);  // Save all regs...
2706         WrMemB(--srB, urB&0xFF);   WrMemB(--srB, urB>>8);
2707         WrMemB(--srB, yrB&0xFF);   WrMemB(--srB, yrB>>8);
2708         WrMemB(--srB, xrB&0xFF);   WrMemB(--srB, xrB>>8);
2709         WrMemB(--srB, dprB);       WrMemB(--srB, brB);
2710         WrMemB(--srB, arB);        WrMemB(--srB, ccrB);
2711         ccrB |= 0x50;         // Set F,I
2712         pcrB = (RdMemB(0xFFF8)<<8) | RdMemB(0xFFF9);  // And do it!
2713       }
2714     }
2715   }
2716 }