home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / programs / emulaton / at2600 / !v2600 / c / cpu < prev    next >
Text File  |  1998-04-09  |  81KB  |  5,006 lines
  1. /*****************************************************************************
  2.  
  3.    This file is part of x2600, the Atari 2600 Emulator
  4.    ===================================================
  5.  
  6.    Copyright 1996 Alex Hornby. For contributions see the file CREDITS.
  7.  
  8.    This software is distributed under the terms of the GNU General Public
  9.    License. This is free software with ABSOLUTELY NO WARRANTY.
  10.  
  11.    See the file COPYING for details.
  12.  
  13.    $Id: cpu.c,v 1.11.1.10 1997/02/23 20:39:29 ahornby Exp $
  14. ******************************************************************************/
  15. /*
  16.  * 6507 CPU emulation
  17.  *
  18.  * Originally from X64
  19.  * Modified by Alex Hornby for use in x2600
  20.  * See COPYING for license terms
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include "sys/types.h"
  26. #include "cpu.h"
  27. #include "macro.h"
  28. #include "vmachine.h"
  29. #include "memory.h"
  30. #include "display.h"
  31. #include "config.h"
  32. #include "exmacro.h"
  33.  
  34. /* Verbose output flag from X64 debugging code */
  35. int verflg = 0;
  36.  
  37. /* Hex output flag from X64 debugging code */
  38. int hexflg = 0;
  39.  
  40. /* X64 compatible debug code. depreciated */
  41. void
  42. mon (ADDRESS a)
  43. {
  44. }
  45.  
  46. /* X64 compatible debug code. depreciated */
  47. #ifdef DEBUG
  48. #include "memory.h"
  49. int rd[RAMSIZE];
  50. int wr[RAMSIZE];
  51. long instructions[256];
  52. #endif
  53.  
  54. /* The X based debugger prototypes */
  55. #ifdef XDEBUGGER
  56. extern void x_loop (void);
  57. extern void set_single (void);
  58. #endif
  59.  
  60. /* CPU internals */
  61. ADDRESS program_counter;
  62. BYTE x_register, y_register, stack_pointer;
  63. BYTE accumulator, status_register;
  64. int zero_flag;
  65. int sign_flag;
  66. int overflow_flag;
  67. int break_flag;
  68. int decimal_flag;
  69. int interrupt_flag;
  70. int carry_flag;
  71.  
  72. /* CPU Clock counts */
  73. /* Aggregate */
  74. CLOCK clk;
  75. /* Current instruction */
  76. CLOCK clkcount = 0;
  77.  
  78. /* Electron beam adjuctment values for nine and twelve colour clock ins. */
  79. #define BEAMNINE 5
  80. #define BEAMTWELVE 9
  81. int beamadj;
  82.  
  83. /* Used in undocumented 6507 instructions */
  84. /* These are unusual and have no discernable use, but here it is. */
  85. /* val: register to be acted upon */
  86. /* address: address to take high byte from */
  87. /* index: index to add to calculated address */
  88. #ifndef NO_UNDOC_CMDS
  89. void
  90. u_stoshr (unsigned int val, ADDRESS address, BYTE index)
  91. {
  92.   val &= (((address >> 8) + 1) & 0xff);
  93.   if (((address & 0xff) + index) > 0xff)
  94.     address = val;
  95.   STORE ((address + index), val);
  96. }
  97. #endif /* UNDOC */
  98.  
  99. /* Initialise the CPU */
  100. /* addr: reset vector address */
  101. /* Called from init_hardware() */
  102. void
  103. init_cpu (ADDRESS addr)
  104. {
  105.   SET_SR (0x20);
  106.   SP = 0xff;
  107.   PC = LOAD_ADDR (addr);
  108.   clk = 0;
  109.   clkcount = 0;
  110. }
  111.  
  112. /* The main emulation loop, performs the CPU emulation */
  113.  
  114.  
  115. void
  116. emucpu (void)
  117. {
  118.   register BYTE b;
  119.  
  120.   do_screen((int)clkcount); /* in wimp mode, generates update_window's, otherwise, plots direct. */
  121.  
  122.  
  123.       b = LOADEXEC (PC);
  124.       beamadj = 0;
  125.  
  126.       switch (b)
  127.         {
  128.         case 0:
  129.           {
  130.         PC++;
  131.         /* Force break. */
  132.  
  133.  
  134.         SET_BREAK (1);    /* Set break status. */
  135.         PUSH (UPPER (PC));
  136.         PUSH (LOWER (PC));    /* Push return address into the stack. */
  137.         PUSH (GET_SR ());    /* Push status register into the stack. */
  138.         SET_INTERRUPT (1);    /* Disable interrupts. */
  139.         PC = LOAD_ADDR ((ADDRESS) 65534);    /* Jump using BRK vector (0xfffe). */
  140.         clkcount = 7;
  141.           }
  142.           break;
  143.  
  144.         case 1:
  145.           {
  146.         register p1 = LOAD (PC + 1);
  147.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  148.         PC += 2;
  149.  
  150.         src |= AC;
  151.         SET_SIGN (src);
  152.         SET_ZERO (src);
  153.  
  154.         AC = (src);;
  155.         clkcount = 6;
  156.           }
  157.  
  158.           break;
  159.  
  160.         case 2:
  161.           {
  162.         PC++;
  163.         /* No such opcode. */
  164.         (void) printf ("Illegal instruction.\n");
  165.         verflg = 1;
  166.         --PC;
  167.         mon (PC);
  168.           }
  169.  
  170.           break;
  171.  
  172.         case 3:
  173.           {
  174.         register p1 = LOAD (PC + 1);
  175.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  176.         PC += 2;
  177.  
  178.         /* src = asl(src); AC = ora(src); */
  179.  
  180.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  181.         src <<= 1;
  182.         src |= AC;
  183.         src &= 0xff;
  184.         SET_SIGN (src);
  185.         SET_ZERO (src);
  186.  
  187.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  188.         clkcount = 8;
  189.           }
  190.  
  191.           break;
  192.  
  193.         case 4:
  194.           {
  195.         PC += 2;
  196.  
  197.         clkcount = 3;
  198.           }
  199.  
  200.           break;
  201.  
  202.         case 5:
  203.           {
  204.         register p1 = LOAD (PC + 1);
  205.         register unsigned src = LOAD_ZERO (p1);
  206.         PC += 2;
  207.  
  208.         src |= AC;
  209.         SET_SIGN (src);
  210.         SET_ZERO (src);
  211.  
  212.         AC = (src);;
  213.         clkcount = 3;
  214.           }
  215.  
  216.           break;
  217.  
  218.         case 6:
  219.           {
  220.         register p1 = LOAD (PC + 1);
  221.         register unsigned src = LOAD_ZERO (p1);
  222.         PC += 2;
  223.  
  224.         SET_CARRY (src & 0x80);
  225.         src <<= 1;
  226.         src &= 0xff;
  227.         SET_SIGN (src);
  228.         SET_ZERO (src);
  229.  
  230.         STORE_ZERO (p1, (src));;
  231.         clkcount = 5;
  232.           }
  233.  
  234.           break;
  235.  
  236.         case 7:
  237.           {
  238.         register p1 = LOAD (PC + 1);
  239.         register unsigned src = LOAD_ZERO (p1);
  240.         PC += 2;
  241.  
  242.         /* src = asl(src); AC = ora(src); */
  243.  
  244.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  245.         src <<= 1;
  246.         src |= AC;
  247.         src &= 0xff;
  248.         SET_SIGN (src);
  249.         SET_ZERO (src);
  250.  
  251.         STORE_ZERO (p1, (src));;
  252.         clkcount = 5;
  253.           }
  254.  
  255.           break;
  256.  
  257.         case 8:
  258.           {
  259.         register unsigned src = GET_SR ();
  260.         PC++;
  261.  
  262.         PUSH (src);
  263.         /* First push item onto stack and then decrement SP. */
  264.         clkcount = 3;
  265.           }
  266.  
  267.           break;
  268.  
  269.         case 9:
  270.           {
  271.         register p1 = LOAD (PC + 1);
  272.         register unsigned src = p1;
  273.         PC += 2;
  274.  
  275.         src |= AC;
  276.         SET_SIGN (src);
  277.         SET_ZERO (src);
  278.  
  279.         AC = (src);;
  280.         clkcount = 2;
  281.           }
  282.  
  283.           break;
  284.  
  285.         case 10:
  286.           {
  287.         register unsigned src = AC;
  288.         PC++;
  289.  
  290.         SET_CARRY (src & 0x80);
  291.         src <<= 1;
  292.         src &= 0xff;
  293.         SET_SIGN (src);
  294.         SET_ZERO (src);
  295.  
  296.         AC = (src);;
  297.         clkcount = 2;
  298.           }
  299.  
  300.           break;
  301.  
  302.         case 11:
  303.           {
  304.         register p1 = LOAD (PC + 1);
  305.         register unsigned src = (AC & p1);
  306.         PC += 2;
  307.  
  308.         src &= AC;
  309.         SET_SIGN (src);
  310.         SET_ZERO (src);
  311.  
  312.         AC = (src);;
  313.         clkcount = 2;
  314.           }
  315.  
  316.           break;
  317.  
  318.         case 12:
  319.           {
  320.         PC += 3;
  321.  
  322.         clkcount = 4;
  323.           }
  324.  
  325.           break;
  326.  
  327.         case 13:
  328.           {
  329.         register p2 = load_abs_addr ();
  330.         register unsigned src = LOAD (p2);
  331.         PC += 3;
  332.  
  333.         src |= AC;
  334.         SET_SIGN (src);
  335.         SET_ZERO (src);
  336.  
  337.         AC = (src);;
  338.         clkcount = 4;
  339.           }
  340.  
  341.           break;
  342.  
  343.         case 14:
  344.           {
  345.         register p2 = load_abs_addr ();
  346.         register unsigned src = LOAD (p2);
  347.         PC += 3;
  348.  
  349.         SET_CARRY (src & 0x80);
  350.         src <<= 1;
  351.         src &= 0xff;
  352.         SET_SIGN (src);
  353.         SET_ZERO (src);
  354.  
  355.         STORE (p2, (src));;
  356.         clkcount = 6;
  357.           }
  358.  
  359.           break;
  360.  
  361.         case 15:
  362.           {
  363.         register p2 = load_abs_addr ();
  364.         register unsigned src = LOAD (p2);
  365.         PC += 3;
  366.  
  367.         /* src = asl(src); AC = ora(src); */
  368.  
  369.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  370.         src <<= 1;
  371.         src |= AC;
  372.         src &= 0xff;
  373.         SET_SIGN (src);
  374.         SET_ZERO (src);
  375.  
  376.         STORE (p2, (src));;
  377.         clkcount = 6;
  378.           }
  379.  
  380.           break;
  381.  
  382.         case 16:
  383. /*  BPL,    RELATIVE */
  384.           {
  385.         register p1 = LOAD (PC + 1);
  386.         register unsigned src = p1;
  387.         register BYTE hb;
  388.         PC += 2;
  389.         /* Branch if sign flag is clear. */
  390.         if (!IF_SIGN ())
  391.           {
  392.             hb = UPPER (PC);
  393.             PC = REL_ADDR (PC, src);
  394.             if (brtest (hb))
  395.               /* Same page */
  396.               clkcount = 3;
  397.             else
  398.               /* Different page */
  399.               clkcount = 4;
  400.           }
  401.         else
  402.           clkcount = 2;
  403.           }
  404.  
  405.           break;
  406.  
  407.         case 17:
  408. /* ORA,    INDIRECT_Y */
  409.           {
  410.         register p1 = LOAD (PC + 1);
  411.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  412.         register unsigned src = LOAD (p2 + YR);
  413.         PC += 2;
  414.  
  415.         /* If low byte of address  + index reg is > 0xff then extra cycle */
  416.         if (pagetest (p2, YR))
  417.           /* Over page */
  418.           clkcount = 6;
  419.         else
  420.           /* Same page */
  421.           clkcount = 5;
  422.         src |= AC;
  423.         SET_SIGN (src);
  424.         SET_ZERO (src);
  425.  
  426.         AC = (src);;
  427.           }
  428.  
  429.           break;
  430.  
  431.         case 18:
  432.           {
  433.         PC++;
  434.         /* No such opcode. */
  435.         (void) printf ("Illegal instruction.\n");
  436.         verflg = 1;
  437.         --PC;
  438.         mon (PC);
  439.           }
  440.  
  441.           break;
  442.  
  443.         case 19:
  444.           {
  445.         register p1 = LOAD (PC + 1);
  446.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  447.         PC += 2;
  448.  
  449.         /* src = asl(src); AC = ora(src); */
  450.  
  451.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  452.         src <<= 1;
  453.         src |= AC;
  454.         src &= 0xff;
  455.         SET_SIGN (src);
  456.         SET_ZERO (src);
  457.  
  458.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  459.         clkcount = 8;
  460.           }
  461.  
  462.           break;
  463.  
  464.         case 20:
  465.           {
  466.         PC += 2;
  467.  
  468.         clkcount = 4;
  469.           }
  470.  
  471.           break;
  472.  
  473.         case 21:
  474.           {
  475.         register p1 = LOAD (PC + 1);
  476.         register unsigned src = LOAD_ZERO (p1 + XR);
  477.         PC += 2;
  478.  
  479.         src |= AC;
  480.         SET_SIGN (src);
  481.         SET_ZERO (src);
  482.  
  483.         AC = (src);;
  484.         clkcount = 4;
  485.           }
  486.  
  487.           break;
  488.  
  489.         case 22:
  490.           {
  491.         register p1 = LOAD (PC + 1);
  492.         register unsigned src = LOAD_ZERO (p1 + XR);
  493.         PC += 2;
  494.  
  495.         SET_CARRY (src & 0x80);
  496.         src <<= 1;
  497.         src &= 0xff;
  498.         SET_SIGN (src);
  499.         SET_ZERO (src);
  500.  
  501.         STORE_ZERO (p1 + XR, (src));;
  502.         clkcount = 6;
  503.           }
  504.  
  505.           break;
  506.  
  507.         case 23:
  508.           {
  509.         register p1 = LOAD (PC + 1);
  510.         register unsigned src = LOAD_ZERO (p1 + XR);
  511.         PC += 2;
  512.  
  513.         /* src = asl(src); AC = ora(src); */
  514.  
  515.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  516.         src <<= 1;
  517.         src |= AC;
  518.         src &= 0xff;
  519.         SET_SIGN (src);
  520.         SET_ZERO (src);
  521.  
  522.         STORE_ZERO (p1 + XR, (src));;
  523.         clkcount = 6;
  524.           }
  525.  
  526.           break;
  527.  
  528.         case 24:
  529.           {
  530.         PC++;
  531.  
  532.  
  533.         SET_CARRY ((0));;
  534.         clkcount = 2;
  535.           }
  536.  
  537.           break;
  538.  
  539.         case 25:
  540. /*  ORA,    ABSOLUTE_Y */
  541.           {
  542.         register p2 = load_abs_addr ();
  543.         register unsigned src = LOAD (p2 + YR);
  544.         PC += 3;
  545.  
  546.         if (pagetest (p2, YR))
  547.           /* Over page */
  548.           clkcount = 5;
  549.         else
  550.           /* Same page */
  551.           clkcount = 4;
  552.  
  553.         src |= AC;
  554.         SET_SIGN (src);
  555.         SET_ZERO (src);
  556.  
  557.         AC = (src);;
  558.           }
  559.  
  560.           break;
  561.  
  562.         case 26:
  563.           {
  564.         PC++;
  565.  
  566.         clkcount = 2;
  567.           }
  568.  
  569.           break;
  570.  
  571.         case 27:
  572.           {
  573.         register p2 = load_abs_addr ();
  574.         register unsigned src = LOAD (p2 + YR);
  575.         PC += 3;
  576.  
  577.         /* src = asl(src); AC = ora(src); */
  578.  
  579.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  580.         src <<= 1;
  581.         src |= AC;
  582.         src &= 0xff;
  583.         SET_SIGN (src);
  584.         SET_ZERO (src);
  585.  
  586.         STORE (p2 + YR, (src));;
  587.         clkcount = 7;
  588.           }
  589.  
  590.           break;
  591.  
  592.         case 28:
  593.           {
  594.         PC += 3;
  595.  
  596.         clkcount = 4;
  597.           }
  598.  
  599.           break;
  600.  
  601.         case 29:
  602. /*   ORA,    ABSOLUTE_X */
  603.           {
  604.         register p2 = load_abs_addr ();
  605.         register unsigned src = LOAD (p2 + XR);
  606.         PC += 3;
  607.  
  608.         if (pagetest (p2, XR))
  609.           /* Over page */
  610.           clkcount = 5;
  611.         else
  612.           /* Same page */
  613.           clkcount = 4;
  614.  
  615.         src |= AC;
  616.         SET_SIGN (src);
  617.         SET_ZERO (src);
  618.  
  619.         AC = (src);;
  620.           }
  621.  
  622.           break;
  623.  
  624.         case 30:
  625.           {
  626.         register p2 = load_abs_addr ();
  627.         register unsigned src = LOAD (p2 + XR);
  628.         PC += 3;
  629.  
  630.         SET_CARRY (src & 0x80);
  631.         src <<= 1;
  632.         src &= 0xff;
  633.         SET_SIGN (src);
  634.         SET_ZERO (src);
  635.  
  636.         STORE (p2 + XR, (src));;
  637.         clkcount = 7;
  638.           }
  639.  
  640.           break;
  641.  
  642.         case 31:
  643.           {
  644.         register p2 = load_abs_addr ();
  645.         register unsigned src = LOAD (p2 + XR);
  646.         PC += 3;
  647.  
  648.         /* src = asl(src); AC = ora(src); */
  649.  
  650.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  651.         src <<= 1;
  652.         src |= AC;
  653.         src &= 0xff;
  654.         SET_SIGN (src);
  655.         SET_ZERO (src);
  656.  
  657.         STORE (p2 + XR, (src));;
  658.         clkcount = 7;
  659.           }
  660.  
  661.           break;
  662.  
  663.         case 32:
  664.           {
  665.         register p2 = load_abs_addr ();
  666.         register unsigned src = p2;
  667.         PC += 3;
  668.         /* Jump to subroutine. */
  669.         PC--;
  670.         PUSH ((PC >> 8) & 0xff);    /* Push return address onto the stack. */
  671.         PUSH (PC & 0xff);
  672.  
  673. #ifdef DEBUG
  674.         if (traceflg)
  675.           print_stack (SP);
  676. #endif
  677.  
  678.  
  679.         PC = (src);;
  680.         clkcount = 6;
  681.           }
  682.  
  683.           break;
  684.  
  685.         case 33:
  686.           {
  687.         register p1 = LOAD (PC + 1);
  688.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  689.         PC += 2;
  690.  
  691.         src &= AC;
  692.         SET_SIGN (src);
  693.         SET_ZERO (src);
  694.  
  695.         AC = (src);;
  696.         clkcount = 6;
  697.           }
  698.  
  699.           break;
  700.  
  701.         case 34:
  702.           {
  703.         PC++;
  704.         /* No such opcode. */
  705.         (void) printf ("Illegal instruction.\n");
  706.         verflg = 1;
  707.         --PC;
  708.  
  709.         mon (PC);
  710.           }
  711.  
  712.           break;
  713.  
  714.         case 35:
  715.           {
  716.         register p1 = LOAD (PC + 1);
  717.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  718.         PC += 2;
  719.  
  720.         /* src = rol(src); AC = and(src); */
  721.  
  722.         src <<= 1;
  723.         if (IF_CARRY ())    /* ROL+AND */
  724.           src |= 0x1;
  725.         SET_CARRY (src > 0xff);
  726.         src &= 0xff;
  727.  
  728.         AC &= src;
  729.         SET_SIGN (AC);
  730.         SET_ZERO (AC);
  731.         /* rotated, not disturbed */
  732.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  733.         clkcount = 8;
  734.           }
  735.  
  736.           break;
  737.  
  738.         case 36:
  739.           {
  740.         register p1 = LOAD (PC + 1);
  741.         register unsigned src = LOAD_ZERO (p1);
  742.         PC += 2;
  743.  
  744.         SET_SIGN (src);
  745.         SET_OVERFLOW (0x40 & src);    /* Copy bit 6 to OVERFLOW flag. */
  746.         SET_ZERO (src & AC);
  747.         clkcount = 3;
  748.           }
  749.  
  750.           break;
  751.  
  752.         case 37:
  753.           {
  754.         register p1 = LOAD (PC + 1);
  755.         register unsigned src = LOAD_ZERO (p1);
  756.         PC += 2;
  757.  
  758.         src &= AC;
  759.         SET_SIGN (src);
  760.         SET_ZERO (src);
  761.  
  762.         AC = (src);;
  763.         clkcount = 3;
  764.           }
  765.  
  766.           break;
  767.  
  768.         case 38:
  769.           {
  770.         register p1 = LOAD (PC + 1);
  771.         register unsigned src = LOAD_ZERO (p1);
  772.         PC += 2;
  773.  
  774.         src <<= 1;
  775.         if (IF_CARRY ())
  776.           src |= 0x1;
  777.         SET_CARRY (src > 0xff);
  778.         src &= 0xff;
  779.         SET_SIGN (src);
  780.         SET_ZERO (src);
  781.  
  782.         STORE_ZERO (p1, (src));;
  783.         clkcount = 5;
  784.           }
  785.  
  786.           break;
  787.  
  788.         case 39:
  789.           {
  790.         register p1 = LOAD (PC + 1);
  791.         register unsigned src = LOAD_ZERO (p1);
  792.         PC += 2;
  793.  
  794.         /* src = rol(src); AC = and(src); */
  795.  
  796.         src <<= 1;
  797.         if (IF_CARRY ())    /* ROL+AND */
  798.           src |= 0x1;
  799.         SET_CARRY (src > 0xff);
  800.         src &= 0xff;
  801.  
  802.         AC &= src;
  803.         SET_SIGN (AC);
  804.         SET_ZERO (AC);
  805.         /* rotated, not disturbed */
  806.         STORE_ZERO (p1, (src));;
  807.         clkcount = 5;
  808.           }
  809.  
  810.           break;
  811.  
  812.         case 40:
  813.           {
  814.         register unsigned src;
  815.         PC++;
  816.  
  817.         /* First increment stack pointer and then pull item from stack. */
  818.         src = PULL ();
  819.  
  820.         SET_SR ((src));;
  821.         clkcount = 4;
  822.           }
  823.  
  824.           break;
  825.  
  826.         case 41:
  827.           {
  828.         register p1 = LOAD (PC + 1);
  829.         register unsigned src = p1;
  830.         PC += 2;
  831.  
  832.         src &= AC;
  833.         SET_SIGN (src);
  834.         SET_ZERO (src);
  835.  
  836.         AC = (src);;
  837.         clkcount = 2;
  838.           }
  839.  
  840.           break;
  841.  
  842.         case 42:
  843.           {
  844.         register unsigned src = AC;
  845.         PC++;
  846.  
  847.         src <<= 1;
  848.         if (IF_CARRY ())
  849.           src |= 0x1;
  850.         SET_CARRY (src > 0xff);
  851.         src &= 0xff;
  852.         SET_SIGN (src);
  853.         SET_ZERO (src);
  854.  
  855.         AC = (src);;
  856.         clkcount = 2;
  857.           }
  858.  
  859.           break;
  860.  
  861.         case 43:
  862.           {
  863.         register p1 = LOAD (PC + 1);
  864.         register unsigned src = (AC & p1);
  865.         PC += 2;
  866.  
  867.         src &= AC;
  868.         SET_SIGN (src);
  869.         SET_ZERO (src);
  870.  
  871.         AC = (src);;
  872.         clkcount = 2;
  873.           }
  874.  
  875.           break;
  876.  
  877.         case 44:
  878.           {
  879.         register p2 = load_abs_addr ();
  880.         register unsigned src = LOAD (p2);
  881.         PC += 3;
  882.  
  883.         SET_SIGN (src);
  884.         SET_OVERFLOW (0x40 & src);    /* Copy bit 6 to OVERFLOW flag. */
  885.         SET_ZERO (src & AC);
  886.         clkcount = 4;
  887.           }
  888.  
  889.           break;
  890.  
  891.         case 45:
  892.           {
  893.         register p2 = load_abs_addr ();
  894.         register unsigned src = LOAD (p2);
  895.         PC += 3;
  896.  
  897.         src &= AC;
  898.         SET_SIGN (src);
  899.         SET_ZERO (src);
  900.  
  901.         AC = (src);;
  902.         clkcount = 4;
  903.           }
  904.  
  905.           break;
  906.  
  907.         case 46:
  908.           {
  909.         register p2 = load_abs_addr ();
  910.         register unsigned src = LOAD (p2);
  911.         PC += 3;
  912.  
  913.         src <<= 1;
  914.         if (IF_CARRY ())
  915.           src |= 0x1;
  916.         SET_CARRY (src > 0xff);
  917.         src &= 0xff;
  918.         SET_SIGN (src);
  919.         SET_ZERO (src);
  920.  
  921.         STORE (p2, (src));;
  922.         clkcount = 6;
  923.           }
  924.  
  925.           break;
  926.  
  927.         case 47:
  928.           {
  929.         register p2 = load_abs_addr ();
  930.         register unsigned src = LOAD (p2);
  931.         PC += 3;
  932.  
  933.         /* src = rol(src); AC = and(src); */
  934.  
  935.         src <<= 1;
  936.         if (IF_CARRY ())    /* ROL+AND */
  937.           src |= 0x1;
  938.         SET_CARRY (src > 0xff);
  939.         src &= 0xff;
  940.  
  941.         AC &= src;
  942.         SET_SIGN (AC);
  943.         SET_ZERO (AC);
  944.         /* rotated, not disturbed */
  945.         STORE (p2, (src));;
  946.         clkcount = 6;
  947.           }
  948.  
  949.           break;
  950.  
  951.         case 48:
  952. /*   BMI,    RELATIVE */
  953.           {
  954.         register p1 = LOAD (PC + 1);
  955.         register unsigned src = p1;
  956.         register BYTE hb;
  957.         PC += 2;
  958.         /* Branch if sign flag is set. */
  959.         if (IF_SIGN ())
  960.           {
  961.             hb = UPPER (PC);
  962.             PC = REL_ADDR (PC, src);
  963.             if (brtest (hb))
  964.               /* Same page */
  965.               clkcount = 3;
  966.             else
  967.               /* Different page */
  968.               clkcount = 4;
  969.           }
  970.         else
  971.           clkcount = 2;
  972.           }
  973.  
  974.           break;
  975.  
  976.         case 49:
  977. /*  AND,    INDIRECT_Y */
  978.           {
  979.         register p1 = LOAD (PC + 1);
  980.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  981.         register unsigned src = LOAD (p2 + YR);
  982.         PC += 2;
  983.         if (pagetest (p2, YR))
  984.           /* Over page */
  985.           clkcount = 6;
  986.         else
  987.           /* Same page */
  988.           clkcount = 5;
  989.  
  990.         src &= AC;
  991.         SET_SIGN (src);
  992.         SET_ZERO (src);
  993.  
  994.         AC = (src);;
  995.           }
  996.  
  997.           break;
  998.  
  999.         case 50:
  1000.           {
  1001.         PC++;
  1002.         /* No such opcode. */
  1003.         (void) printf ("Illegal instruction.\n");
  1004.         verflg = 1;
  1005.         --PC;
  1006.  
  1007.         mon (PC);
  1008.           }
  1009.  
  1010.           break;
  1011.  
  1012.         case 51:
  1013.           {
  1014.         register p1 = LOAD (PC + 1);
  1015.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  1016.         PC += 2;
  1017.  
  1018.         /* src = rol(src); AC = and(src); */
  1019.  
  1020.         src <<= 1;
  1021.         if (IF_CARRY ())    /* ROL+AND */
  1022.           src |= 0x1;
  1023.         SET_CARRY (src > 0xff);
  1024.         src &= 0xff;
  1025.  
  1026.         AC &= src;
  1027.         SET_SIGN (AC);
  1028.         SET_ZERO (AC);
  1029.         /* rotated, not disturbed */
  1030.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  1031.         clkcount = 8;
  1032.           }
  1033.  
  1034.           break;
  1035.  
  1036.         case 52:
  1037.           {
  1038.         PC += 2;
  1039.  
  1040.         clkcount = 4;
  1041.           }
  1042.  
  1043.           break;
  1044.  
  1045.         case 53:
  1046.           {
  1047.         register p1 = LOAD (PC + 1);
  1048.         register unsigned src = LOAD_ZERO (p1 + XR);
  1049.         PC += 2;
  1050.  
  1051.         src &= AC;
  1052.         SET_SIGN (src);
  1053.         SET_ZERO (src);
  1054.  
  1055.         AC = (src);;
  1056.         clkcount = 4;
  1057.           }
  1058.  
  1059.           break;
  1060.  
  1061.         case 54:
  1062.           {
  1063.         register p1 = LOAD (PC + 1);
  1064.         register unsigned src = LOAD_ZERO (p1 + XR);
  1065.         PC += 2;
  1066.  
  1067.         src <<= 1;
  1068.         if (IF_CARRY ())
  1069.           src |= 0x1;
  1070.         SET_CARRY (src > 0xff);
  1071.         src &= 0xff;
  1072.         SET_SIGN (src);
  1073.         SET_ZERO (src);
  1074.  
  1075.         STORE_ZERO (p1 + XR, (src));;
  1076.         clkcount = 6;
  1077.           }
  1078.  
  1079.           break;
  1080.  
  1081.         case 55:
  1082.           {
  1083.         register p1 = LOAD (PC + 1);
  1084.         register unsigned src = LOAD_ZERO (p1 + XR);
  1085.         PC += 2;
  1086.  
  1087.         /* src = rol(src); AC = and(src); */
  1088.  
  1089.         src <<= 1;
  1090.         if (IF_CARRY ())    /* ROL+AND */
  1091.           src |= 0x1;
  1092.         SET_CARRY (src > 0xff);
  1093.         src &= 0xff;
  1094.  
  1095.         AC &= src;
  1096.         SET_SIGN (AC);
  1097.         SET_ZERO (AC);
  1098.         /* rotated, not disturbed */
  1099.         STORE_ZERO (p1 + XR, (src));;
  1100.         clkcount = 6;
  1101.           }
  1102.  
  1103.           break;
  1104.  
  1105.         case 56:
  1106.           {
  1107.         PC++;
  1108.  
  1109.  
  1110.         SET_CARRY ((1));;
  1111.         clkcount = 2;
  1112.           }
  1113.  
  1114.           break;
  1115.  
  1116.         case 57:
  1117. /*  AND,    ABSOLUTE_Y */
  1118.           {
  1119.         register p2 = load_abs_addr ();
  1120.         register unsigned src = LOAD (p2 + YR);
  1121.         PC += 3;
  1122.         if (pagetest (p2, YR))
  1123.           /* Over page */
  1124.           clkcount = 5;
  1125.         else
  1126.           /* Same page */
  1127.           clkcount = 4;
  1128.         src &= AC;
  1129.         SET_SIGN (src);
  1130.         SET_ZERO (src);
  1131.  
  1132.         AC = (src);
  1133.           }
  1134.  
  1135.           break;
  1136.  
  1137.         case 58:
  1138.           {
  1139.         PC++;
  1140.  
  1141.         clkcount = 2;
  1142.           }
  1143.  
  1144.           break;
  1145.  
  1146.         case 59:
  1147.           {
  1148.         register p2 = load_abs_addr ();
  1149.         register unsigned src = LOAD (p2 + YR);
  1150.         PC += 3;
  1151.  
  1152.         /* src = rol(src); AC = and(src); */
  1153.  
  1154.         src <<= 1;
  1155.         if (IF_CARRY ())    /* ROL+AND */
  1156.           src |= 0x1;
  1157.         SET_CARRY (src > 0xff);
  1158.         src &= 0xff;
  1159.  
  1160.         AC &= src;
  1161.         SET_SIGN (AC);
  1162.         SET_ZERO (AC);
  1163.         /* rotated, not disturbed */
  1164.         STORE (p2 + YR, (src));;
  1165.         clkcount = 7;
  1166.           }
  1167.  
  1168.           break;
  1169.  
  1170.         case 60:
  1171.           {
  1172.         PC += 3;
  1173.  
  1174.         clkcount = 4;
  1175.           }
  1176.  
  1177.           break;
  1178.  
  1179.         case 61:
  1180. /*   AND,    ABSOLUTE_X */
  1181.           {
  1182.         register p2 = load_abs_addr ();
  1183.         register unsigned src = LOAD (p2 + XR);
  1184.         PC += 3;
  1185.         if (pagetest (p2, XR))
  1186.           /* Over page */
  1187.           clkcount = 5;
  1188.         else
  1189.           /* Same page */
  1190.           clkcount = 4;
  1191.         src &= AC;
  1192.         SET_SIGN (src);
  1193.         SET_ZERO (src);
  1194.  
  1195.         AC = (src);;
  1196.           }
  1197.  
  1198.           break;
  1199.  
  1200.         case 62:
  1201.           {
  1202.         register p2 = load_abs_addr ();
  1203.         register unsigned src = LOAD (p2 + XR);
  1204.         PC += 3;
  1205.  
  1206.         src <<= 1;
  1207.         if (IF_CARRY ())
  1208.           src |= 0x1;
  1209.         SET_CARRY (src > 0xff);
  1210.         src &= 0xff;
  1211.         SET_SIGN (src);
  1212.         SET_ZERO (src);
  1213.  
  1214.         STORE (p2 + XR, (src));;
  1215.         clkcount = 7;
  1216.           }
  1217.  
  1218.           break;
  1219.  
  1220.         case 63:
  1221.           {
  1222.         register p2 = load_abs_addr ();
  1223.         register unsigned src = LOAD (p2 + XR);
  1224.         PC += 3;
  1225.  
  1226.         /* src = rol(src); AC = and(src); */
  1227.  
  1228.         src <<= 1;
  1229.         if (IF_CARRY ())    /* ROL+AND */
  1230.           src |= 0x1;
  1231.         SET_CARRY (src > 0xff);
  1232.         src &= 0xff;
  1233.  
  1234.         AC &= src;
  1235.         SET_SIGN (AC);
  1236.         SET_ZERO (AC);
  1237.         /* rotated, not disturbed */
  1238.         STORE (p2 + XR, (src));;
  1239.         clkcount = 7;
  1240.           }
  1241.  
  1242.           break;
  1243.  
  1244.         case 64:
  1245.           {
  1246.         register unsigned src;
  1247.         PC++;
  1248.         /* Return from interrupt. */
  1249.         /* Load program status and program counter from stack. */
  1250.         src = PULL ();
  1251.         SET_SR (src);
  1252.         src = PULL ();
  1253.         src |= (PULL () << 8);    /* Load return address from stack. */
  1254.  
  1255. #ifdef DEBUG
  1256.         if (traceflg)
  1257.           print_stack (SP);
  1258. #endif
  1259.  
  1260.  
  1261.         PC = (src);;
  1262.         clkcount = 6;
  1263.           }
  1264.  
  1265.           break;
  1266.  
  1267.         case 65:
  1268.           {
  1269.         register p1 = LOAD (PC + 1);
  1270.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1271.         PC += 2;
  1272.  
  1273.         src ^= AC;
  1274.         SET_SIGN (src);
  1275.         SET_ZERO (src);
  1276.  
  1277.         AC = (src & 0xff);;
  1278.         clkcount = 6;
  1279.           }
  1280.  
  1281.           break;
  1282.  
  1283.         case 66:
  1284.           {
  1285.         PC++;
  1286.         /* No such opcode. */
  1287.         (void) printf ("Illegal instruction.\n");
  1288.         verflg = 1;
  1289.         --PC;
  1290.  
  1291.         mon (PC);
  1292.           }
  1293.  
  1294.           break;
  1295.  
  1296.         case 67:
  1297.           {
  1298.         register p1 = LOAD (PC + 1);
  1299.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1300.         PC += 2;
  1301.  
  1302.         /* src = lsr(src); AC = eor(src); */
  1303.  
  1304.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1305.         src >>= 1;
  1306.         src ^= AC;
  1307.         src &= 0xff;
  1308.         SET_SIGN (src);
  1309.         SET_ZERO (src);
  1310.  
  1311.  
  1312.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  1313.         clkcount = 8;
  1314.           }
  1315.  
  1316.           break;
  1317.  
  1318.         case 68:
  1319.           {
  1320.         PC += 2;
  1321.  
  1322.         clkcount = 3;
  1323.           }
  1324.  
  1325.           break;
  1326.  
  1327.         case 69:
  1328.           {
  1329.         register p1 = LOAD (PC + 1);
  1330.         register unsigned src = LOAD_ZERO (p1);
  1331.         PC += 2;
  1332.  
  1333.         src ^= AC;
  1334.         SET_SIGN (src);
  1335.         SET_ZERO (src);
  1336.  
  1337.         AC = (src & 0xff);;
  1338.         clkcount = 3;
  1339.           }
  1340.  
  1341.           break;
  1342.  
  1343.         case 70:
  1344.           {
  1345.         register p1 = LOAD (PC + 1);
  1346.         register unsigned src = LOAD_ZERO (p1);
  1347.         PC += 2;
  1348.  
  1349.         SET_CARRY (src & 0x01);
  1350.         src >>= 1;
  1351.  
  1352.         SET_SIGN (src);
  1353.         SET_ZERO (src);
  1354.  
  1355.         STORE_ZERO (p1, (src));;
  1356.         clkcount = 5;
  1357.           }
  1358.  
  1359.           break;
  1360.  
  1361.         case 71:
  1362.           {
  1363.         register p1 = LOAD (PC + 1);
  1364.         register unsigned src = LOAD_ZERO (p1);
  1365.         PC += 2;
  1366.  
  1367.         /* src = lsr(src); AC = eor(src); */
  1368.  
  1369.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1370.         src >>= 1;
  1371.         src ^= AC;
  1372.         src &= 0xff;
  1373.         SET_SIGN (src);
  1374.         SET_ZERO (src);
  1375.  
  1376.  
  1377.         STORE_ZERO (p1, (src));;
  1378.         clkcount = 5;
  1379.           }
  1380.  
  1381.           break;
  1382.  
  1383.         case 72:
  1384. /*   PHA,    IMPLIED */
  1385.           {
  1386.         register unsigned src = AC;
  1387.         PC++;
  1388.  
  1389.         beamadj = BEAMNINE;
  1390.         PUSH (src);
  1391.         /* First push item onto stack and then decrement SP. */
  1392.         clkcount = 3;
  1393.           }
  1394.  
  1395.           break;
  1396.  
  1397.         case 73:
  1398.           {
  1399.         register p1 = LOAD (PC + 1);
  1400.         register unsigned src = p1;
  1401.         PC += 2;
  1402.  
  1403.         src ^= AC;
  1404.         SET_SIGN (src);
  1405.         SET_ZERO (src);
  1406.  
  1407.         AC = (src & 0xff);;
  1408.         clkcount = 2;
  1409.           }
  1410.  
  1411.           break;
  1412.  
  1413.         case 74:
  1414.           {
  1415.         register unsigned src = AC;
  1416.         PC++;
  1417.  
  1418.         SET_CARRY (src & 0x01);
  1419.         src >>= 1;
  1420.  
  1421.         SET_SIGN (src);
  1422.         SET_ZERO (src);
  1423.  
  1424.         AC = (src);;
  1425.         clkcount = 2;
  1426.           }
  1427.  
  1428.           break;
  1429.  
  1430.         case 75:
  1431.           {
  1432.         register p1 = LOAD (PC + 1);
  1433.         register unsigned src = (AC & p1);
  1434.         PC += 2;
  1435.  
  1436.         SET_CARRY (src & 0x01);
  1437.         src >>= 1;
  1438.  
  1439.         SET_SIGN (src);
  1440.         SET_ZERO (src);
  1441.  
  1442.         AC = (src);;
  1443.         clkcount = 2;
  1444.           }
  1445.  
  1446.           break;
  1447.  
  1448.         case 76:
  1449.           {
  1450.         register p2 = load_abs_addr ();
  1451.         register unsigned src = p2;
  1452.         PC += 3;
  1453.  
  1454.  
  1455.         PC = (src);;
  1456.         clkcount = 3;
  1457.           }
  1458.  
  1459.           break;
  1460.  
  1461.         case 77:
  1462.           {
  1463.         register p2 = load_abs_addr ();
  1464.         register unsigned src = LOAD (p2);
  1465.         PC += 3;
  1466.  
  1467.         src ^= AC;
  1468.         SET_SIGN (src);
  1469.         SET_ZERO (src);
  1470.  
  1471.         AC = (src & 0xff);;
  1472.         clkcount = 4;
  1473.           }
  1474.  
  1475.           break;
  1476.  
  1477.         case 78:
  1478.           {
  1479.         register p2 = load_abs_addr ();
  1480.         register unsigned src = LOAD (p2);
  1481.         PC += 3;
  1482.  
  1483.         SET_CARRY (src & 0x01);
  1484.         src >>= 1;
  1485.  
  1486.         SET_SIGN (src);
  1487.         SET_ZERO (src);
  1488.  
  1489.         STORE (p2, (src));;
  1490.         clkcount = 6;
  1491.           }
  1492.  
  1493.           break;
  1494.  
  1495.         case 79:
  1496.           {
  1497.         register p2 = load_abs_addr ();
  1498.         register unsigned src = LOAD (p2);
  1499.         PC += 3;
  1500.  
  1501.         /* src = lsr(src); AC = eor(src); */
  1502.  
  1503.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1504.         src >>= 1;
  1505.         src ^= AC;
  1506.         src &= 0xff;
  1507.         SET_SIGN (src);
  1508.         SET_ZERO (src);
  1509.  
  1510.  
  1511.         STORE (p2, (src));;
  1512.         clkcount = 6;
  1513.           }
  1514.  
  1515.           break;
  1516.  
  1517.         case 80:
  1518. /*   BVC,    RELATIVE */
  1519.           {
  1520.         register p1 = LOAD (PC + 1);
  1521.         register unsigned src = p1;
  1522.         register BYTE hb;
  1523.         PC += 2;
  1524.         /* Branch if overflow flag is clear. */
  1525.         if (!IF_OVERFLOW ())
  1526.           {
  1527.             hb = UPPER (PC);
  1528.             PC = REL_ADDR (PC, src);
  1529.             if (brtest (hb))
  1530.               /* Same page */
  1531.               clkcount = 3;
  1532.             else
  1533.               /* Different page */
  1534.               clkcount = 4;
  1535.           }
  1536.         else
  1537.           clkcount = 2;
  1538.           }
  1539.  
  1540.           break;
  1541.  
  1542.         case 81:
  1543. /* EOR,    INDIRECT_Y */
  1544.           {
  1545.         register p1 = LOAD (PC + 1);
  1546.         register p2 = LOAD_ZERO_ADDR (p1);
  1547.         register unsigned src = LOAD (p2 + YR);
  1548.         PC += 2;
  1549.         if (pagetest (p2, YR))
  1550.           /* Over page */
  1551.           clkcount = 6;
  1552.         else
  1553.           /* Same page */
  1554.           clkcount = 5;
  1555.  
  1556.         src ^= AC;
  1557.         SET_SIGN (src);
  1558.         SET_ZERO (src);
  1559.  
  1560.         AC = (src & 0xff);;
  1561.           }
  1562.  
  1563.           break;
  1564.  
  1565.         case 82:
  1566.           {
  1567.         PC++;
  1568.         /* No such opcode. */
  1569.         (void) printf ("Illegal instruction.\n");
  1570.         verflg = 1;
  1571.         --PC;
  1572.  
  1573.         mon (PC);
  1574.           }
  1575.  
  1576.           break;
  1577.  
  1578.         case 83:
  1579.           {
  1580.         register p1 = LOAD (PC + 1);
  1581.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  1582.         PC += 2;
  1583.  
  1584.         /* src = lsr(src); AC = eor(src); */
  1585.  
  1586.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1587.         src >>= 1;
  1588.         src ^= AC;
  1589.         src &= 0xff;
  1590.         SET_SIGN (src);
  1591.         SET_ZERO (src);
  1592.  
  1593.  
  1594.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  1595.         clkcount = 8;
  1596.           }
  1597.  
  1598.           break;
  1599.  
  1600.         case 84:
  1601.           {
  1602.         PC += 2;
  1603.  
  1604.         clkcount = 4;
  1605.           }
  1606.  
  1607.           break;
  1608.  
  1609.         case 85:
  1610.           {
  1611.         register p1 = LOAD (PC + 1);
  1612.         register unsigned src = LOAD_ZERO (p1 + XR);
  1613.         PC += 2;
  1614.  
  1615.         src ^= AC;
  1616.         SET_SIGN (src);
  1617.         SET_ZERO (src);
  1618.  
  1619.         AC = (src & 0xff);;
  1620.         clkcount = 4;
  1621.           }
  1622.  
  1623.           break;
  1624.  
  1625.         case 86:
  1626.           {
  1627.         register p1 = LOAD (PC + 1);
  1628.         register unsigned src = LOAD_ZERO (p1 + XR);
  1629.         PC += 2;
  1630.  
  1631.         SET_CARRY (src & 0x01);
  1632.         src >>= 1;
  1633.  
  1634.         SET_SIGN (src);
  1635.         SET_ZERO (src);
  1636.  
  1637.         STORE_ZERO (p1 + XR, (src));;
  1638.         clkcount = 6;
  1639.           }
  1640.  
  1641.           break;
  1642.  
  1643.         case 87:
  1644.           {
  1645.         register p1 = LOAD (PC + 1);
  1646.         register unsigned src = LOAD_ZERO (p1 + XR);
  1647.         PC += 2;
  1648.  
  1649.         /* src = lsr(src); AC = eor(src); */
  1650.  
  1651.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1652.         src >>= 1;
  1653.         src ^= AC;
  1654.         src &= 0xff;
  1655.         SET_SIGN (src);
  1656.         SET_ZERO (src);
  1657.  
  1658.  
  1659.         STORE_ZERO (p1 + XR, (src));;
  1660.         clkcount = 6;
  1661.           }
  1662.  
  1663.           break;
  1664.  
  1665.         case 88:
  1666.           {
  1667.         PC++;
  1668.  
  1669.  
  1670.         SET_INTERRUPT ((0));;
  1671.         clkcount = 2;
  1672.           }
  1673.  
  1674.           break;
  1675.  
  1676.         case 89:
  1677. /*  EOR,    ABSOLUTE_Y */
  1678.           {
  1679.         register p2 = load_abs_addr ();
  1680.         register unsigned src = LOAD (p2 + YR);
  1681.         PC += 3;
  1682.         if (pagetest (p2, YR))
  1683.           /* Over page */
  1684.           clkcount = 5;
  1685.         else
  1686.           /* Same page */
  1687.           clkcount = 4;
  1688.  
  1689.         src ^= AC;
  1690.         SET_SIGN (src);
  1691.         SET_ZERO (src);
  1692.  
  1693.         AC = (src & 0xff);
  1694.           }
  1695.  
  1696.           break;
  1697.  
  1698.         case 90:
  1699.           {
  1700.         PC++;
  1701.  
  1702.         clkcount = 2;
  1703.           }
  1704.  
  1705.           break;
  1706.  
  1707.         case 91:
  1708.           {
  1709.         register p2 = load_abs_addr ();
  1710.         register unsigned src = LOAD (p2 + YR);
  1711.         PC += 3;
  1712.  
  1713.         /* src = lsr(src); AC = eor(src); */
  1714.  
  1715.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1716.         src >>= 1;
  1717.         src ^= AC;
  1718.         src &= 0xff;
  1719.         SET_SIGN (src);
  1720.         SET_ZERO (src);
  1721.  
  1722.  
  1723.         STORE (p2 + YR, (src));;
  1724.         clkcount = 7;
  1725.           }
  1726.  
  1727.           break;
  1728.  
  1729.         case 92:
  1730.           {
  1731.         PC += 3;
  1732.  
  1733.         clkcount = 4;
  1734.           }
  1735.  
  1736.           break;
  1737.  
  1738.         case 93:
  1739. /*  EOR,    ABSOLUTE_X */
  1740.           {
  1741.         register p2 = load_abs_addr ();
  1742.         register unsigned src = LOAD (p2 + XR);
  1743.         PC += 3;
  1744.         if (pagetest (p2, XR))
  1745.           /* Over page */
  1746.           clkcount = 5;
  1747.         else
  1748.           /* Same page */
  1749.           clkcount = 4;
  1750.  
  1751.         src ^= AC;
  1752.         SET_SIGN (src);
  1753.         SET_ZERO (src);
  1754.  
  1755.         AC = (src & 0xff);;
  1756.           }
  1757.  
  1758.           break;
  1759.  
  1760.         case 94:
  1761.           {
  1762.         register p2 = load_abs_addr ();
  1763.         register unsigned src = LOAD (p2 + XR);
  1764.         PC += 3;
  1765.  
  1766.         SET_CARRY (src & 0x01);
  1767.         src >>= 1;
  1768.  
  1769.         SET_SIGN (src);
  1770.         SET_ZERO (src);
  1771.  
  1772.         STORE (p2 + XR, (src));;
  1773.         clkcount = 7;
  1774.           }
  1775.  
  1776.           break;
  1777.  
  1778.         case 95:
  1779.           {
  1780.         register p2 = load_abs_addr ();
  1781.         register unsigned src = LOAD (p2 + XR);
  1782.         PC += 3;
  1783.  
  1784.         /* src = lsr(src); AC = eor(src); */
  1785.  
  1786.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1787.         src >>= 1;
  1788.         src ^= AC;
  1789.         src &= 0xff;
  1790.         SET_SIGN (src);
  1791.         SET_ZERO (src);
  1792.  
  1793.  
  1794.         STORE (p2 + XR, (src));;
  1795.         clkcount = 7;
  1796.           }
  1797.  
  1798.           break;
  1799.  
  1800.         case 96:
  1801.           {
  1802.         register unsigned src;
  1803.         PC++;
  1804.         /* Return from subroutine. */
  1805.         src = PULL ();
  1806.         src += ((PULL ()) << 8) + 1;    /* Load return address from stack and add 1. */
  1807.  
  1808. #ifdef DEBUG
  1809.         if (traceflg)
  1810.           print_stack (SP);
  1811. #endif
  1812.  
  1813.  
  1814.         PC = (src);;
  1815.         clkcount = 6;
  1816.           }
  1817.  
  1818.           break;
  1819.  
  1820.         case 97:
  1821.           {
  1822.         register p1 = LOAD (PC + 1);
  1823.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1824.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  1825.         PC += 2;
  1826.  
  1827.  
  1828.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  1829.  
  1830.         /*
  1831.          * In decimal mode this is "correct" but not exact emulation. However,
  1832.          * the probability of different result when using undefined BCD codes is
  1833.          * less than 6%
  1834.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  1835.          */
  1836.  
  1837.         if (IF_DECIMAL ())
  1838.           {
  1839.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  1840.               temp += 6;
  1841.  
  1842.             SET_SIGN (temp);
  1843.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1844.  
  1845.             if (temp > 0x99)
  1846.               temp += 96;
  1847.  
  1848.             SET_CARRY (temp > 0x99);
  1849.           }
  1850.         else
  1851.           {
  1852.             SET_SIGN (temp);
  1853.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1854.             SET_CARRY (temp > 0xff);
  1855.           }
  1856.  
  1857.         AC = ((BYTE) temp);;
  1858.         clkcount = 6;
  1859.           }
  1860.  
  1861.           break;
  1862.  
  1863.         case 98:
  1864.           {
  1865.         PC++;
  1866.         /* No such opcode. */
  1867.         (void) printf ("Illegal instruction.\n");
  1868.         verflg = 1;
  1869.         --PC;
  1870.  
  1871.         mon (PC);
  1872.           }
  1873.  
  1874.           break;
  1875.  
  1876.         case 99:
  1877.           {
  1878.         register p1 = LOAD (PC + 1);
  1879.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1880.         register unsigned int temp;
  1881.         PC += 2;
  1882.  
  1883.  
  1884.         /* src = ror(src); AC = adc(src);
  1885.          * the real operation discovered by msmakela
  1886.          * ADC only does the BCD fixup */
  1887.  
  1888.         temp = src >> 1;    /* ROR+ADC */
  1889.         if (IF_CARRY ())
  1890.           temp |= 0x80;
  1891.  
  1892.         SET_SIGN (temp);
  1893.         SET_ZERO (temp);    /* Set flags like ROR does */
  1894.  
  1895.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  1896.  
  1897.         if (IF_DECIMAL ())
  1898.           {
  1899.             if ((src & 0x0f) > 4)    /* half of the normal */
  1900.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  1901.             if (src > 0x4f)
  1902.               temp += 96;
  1903.  
  1904.             SET_CARRY (src > 0x4f);
  1905.           }
  1906.         else
  1907.           {
  1908.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  1909.           }
  1910.  
  1911.  
  1912.         STORE (LOAD_ZERO_ADDR (p1 + XR), ((BYTE) temp));;
  1913.         clkcount = 8;
  1914.           }
  1915.  
  1916.           break;
  1917.  
  1918.         case 100:
  1919.           {
  1920.         PC += 2;
  1921.  
  1922.         clkcount = 3;
  1923.           }
  1924.  
  1925.           break;
  1926.  
  1927.         case 101:
  1928.           {
  1929.         register p1 = LOAD (PC + 1);
  1930.         register unsigned src = LOAD_ZERO (p1);
  1931.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  1932.         PC += 2;
  1933.  
  1934.  
  1935.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  1936.  
  1937.         /*
  1938.          * In decimal mode this is "correct" but not exact emulation. However,
  1939.          * the probability of different result when using undefined BCD codes is
  1940.          * less than 6%
  1941.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  1942.          */
  1943.  
  1944.         if (IF_DECIMAL ())
  1945.           {
  1946.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  1947.               temp += 6;
  1948.  
  1949.             SET_SIGN (temp);
  1950.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1951.  
  1952.             if (temp > 0x99)
  1953.               temp += 96;
  1954.  
  1955.             SET_CARRY (temp > 0x99);
  1956.           }
  1957.         else
  1958.           {
  1959.             SET_SIGN (temp);
  1960.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1961.             SET_CARRY (temp > 0xff);
  1962.           }
  1963.  
  1964.         AC = ((BYTE) temp);;
  1965.         clkcount = 3;
  1966.           }
  1967.  
  1968.           break;
  1969.  
  1970.         case 102:
  1971.           {
  1972.         register p1 = LOAD (PC + 1);
  1973.         register unsigned src = LOAD_ZERO (p1);
  1974.         PC += 2;
  1975.  
  1976.         if (IF_CARRY ())
  1977.           src |= 0x100;
  1978.         SET_CARRY (src & 0x01);
  1979.         src >>= 1;
  1980.  
  1981.         SET_SIGN (src);
  1982.         SET_ZERO (src);
  1983.  
  1984.         STORE_ZERO (p1, (src));;
  1985.         clkcount = 5;
  1986.           }
  1987.  
  1988.           break;
  1989.  
  1990.         case 103:
  1991.           {
  1992.         register p1 = LOAD (PC + 1);
  1993.         register unsigned src = LOAD_ZERO (p1);
  1994.         register unsigned int temp;
  1995.         PC += 2;
  1996.  
  1997.  
  1998.         /* src = ror(src); AC = adc(src);
  1999.          * the real operation discovered by msmakela
  2000.          * ADC only does the BCD fixup */
  2001.  
  2002.         temp = src >> 1;    /* ROR+ADC */
  2003.         if (IF_CARRY ())
  2004.           temp |= 0x80;
  2005.  
  2006.         SET_SIGN (temp);
  2007.         SET_ZERO (temp);    /* Set flags like ROR does */
  2008.  
  2009.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2010.  
  2011.         if (IF_DECIMAL ())
  2012.           {
  2013.             if ((src & 0x0f) > 4)    /* half of the normal */
  2014.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2015.             if (src > 0x4f)
  2016.               temp += 96;
  2017.  
  2018.             SET_CARRY (src > 0x4f);
  2019.           }
  2020.         else
  2021.           {
  2022.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2023.           }
  2024.  
  2025.  
  2026.         STORE_ZERO (p1, ((BYTE) temp));;
  2027.         clkcount = 5;
  2028.           }
  2029.  
  2030.           break;
  2031.  
  2032.         case 104:
  2033. /*   PLA,    IMPLIED */
  2034.           {
  2035.         register unsigned src;
  2036.         PC++;
  2037.  
  2038.         clkcount = 4;
  2039.         /* First increment stack pointer and then pull item from stack. */
  2040.         src = PULL ();
  2041.         SET_SIGN (src);    /* Change sign and zero flag accordingly. */
  2042.         SET_ZERO (src);
  2043.  
  2044.         AC = (src);
  2045.           }
  2046.  
  2047.           break;
  2048.  
  2049.         case 105:
  2050.           {
  2051.         register p1 = LOAD (PC + 1);
  2052.         register unsigned src = p1;
  2053.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2054.         PC += 2;
  2055.  
  2056.  
  2057.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2058.  
  2059.         /*
  2060.          * In decimal mode this is "correct" but not exact emulation. However,
  2061.          * the probability of different result when using undefined BCD codes is
  2062.          * less than 6%
  2063.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2064.          */
  2065.  
  2066.         if (IF_DECIMAL ())
  2067.           {
  2068.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2069.               temp += 6;
  2070.  
  2071.             SET_SIGN (temp);
  2072.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2073.  
  2074.             if (temp > 0x99)
  2075.               temp += 96;
  2076.  
  2077.             SET_CARRY (temp > 0x99);
  2078.           }
  2079.         else
  2080.           {
  2081.             SET_SIGN (temp);
  2082.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2083.             SET_CARRY (temp > 0xff);
  2084.           }
  2085.  
  2086.         AC = ((BYTE) temp);;
  2087.         clkcount = 2;
  2088.           }
  2089.  
  2090.           break;
  2091.  
  2092.         case 106:
  2093.           {
  2094.         register unsigned src = AC;
  2095.         PC++;
  2096.  
  2097.         if (IF_CARRY ())
  2098.           src |= 0x100;
  2099.         SET_CARRY (src & 0x01);
  2100.         src >>= 1;
  2101.  
  2102.         SET_SIGN (src);
  2103.         SET_ZERO (src);
  2104.  
  2105.         AC = (src);;
  2106.         clkcount = 2;
  2107.           }
  2108.  
  2109.           break;
  2110.  
  2111.         case 107:
  2112.           {
  2113.         register p1 = LOAD (PC + 1);
  2114.         register unsigned src = (AC & p1);
  2115.         PC += 2;
  2116.  
  2117.         if (IF_CARRY ())
  2118.           src |= 0x100;
  2119.         SET_CARRY (src & 0x01);
  2120.         src >>= 1;
  2121.  
  2122.         SET_SIGN (src);
  2123.         SET_ZERO (src);
  2124.  
  2125.         AC = (src);;
  2126.         clkcount = 2;
  2127.           }
  2128.  
  2129.           break;
  2130.  
  2131.         case 108:
  2132.           {
  2133.         register p2 = load_abs_addr ();
  2134.         register unsigned src = LOAD_ADDR (p2);
  2135.         PC += 3;
  2136.  
  2137.  
  2138.         PC = (src);;
  2139.         clkcount = 5;
  2140.           }
  2141.  
  2142.           break;
  2143.  
  2144.         case 109:
  2145.           {
  2146.         register p2 = load_abs_addr ();
  2147.         register unsigned src = LOAD (p2);
  2148.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2149.         PC += 3;
  2150.  
  2151.  
  2152.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2153.  
  2154.         /*
  2155.          * In decimal mode this is "correct" but not exact emulation. However,
  2156.          * the probability of different result when using undefined BCD codes is
  2157.          * less than 6%
  2158.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2159.          */
  2160.  
  2161.         if (IF_DECIMAL ())
  2162.           {
  2163.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2164.               temp += 6;
  2165.  
  2166.             SET_SIGN (temp);
  2167.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2168.  
  2169.             if (temp > 0x99)
  2170.               temp += 96;
  2171.  
  2172.             SET_CARRY (temp > 0x99);
  2173.           }
  2174.         else
  2175.           {
  2176.             SET_SIGN (temp);
  2177.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2178.             SET_CARRY (temp > 0xff);
  2179.           }
  2180.  
  2181.         AC = ((BYTE) temp);;
  2182.         clkcount = 4;
  2183.           }
  2184.  
  2185.           break;
  2186.  
  2187.         case 110:
  2188.           {
  2189.         register p2 = load_abs_addr ();
  2190.         register unsigned src = LOAD (p2);
  2191.         PC += 3;
  2192.  
  2193.         if (IF_CARRY ())
  2194.           src |= 0x100;
  2195.         SET_CARRY (src & 0x01);
  2196.         src >>= 1;
  2197.  
  2198.         SET_SIGN (src);
  2199.         SET_ZERO (src);
  2200.  
  2201.         STORE (p2, (src));;
  2202.         clkcount = 6;
  2203.           }
  2204.  
  2205.           break;
  2206.  
  2207.         case 111:
  2208.           {
  2209.         register p2 = load_abs_addr ();
  2210.         register unsigned src = LOAD (p2);
  2211.         register unsigned int temp;
  2212.         PC += 3;
  2213.  
  2214.  
  2215.         /* src = ror(src); AC = adc(src);
  2216.          * the real operation discovered by msmakela
  2217.          * ADC only does the BCD fixup */
  2218.  
  2219.         temp = src >> 1;    /* ROR+ADC */
  2220.         if (IF_CARRY ())
  2221.           temp |= 0x80;
  2222.  
  2223.         SET_SIGN (temp);
  2224.         SET_ZERO (temp);    /* Set flags like ROR does */
  2225.  
  2226.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2227.  
  2228.         if (IF_DECIMAL ())
  2229.           {
  2230.             if ((src & 0x0f) > 4)    /* half of the normal */
  2231.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2232.             if (src > 0x4f)
  2233.               temp += 96;
  2234.  
  2235.             SET_CARRY (src > 0x4f);
  2236.           }
  2237.         else
  2238.           {
  2239.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2240.           }
  2241.  
  2242.  
  2243.         STORE (p2, ((BYTE) temp));;
  2244.         clkcount = 6;
  2245.           }
  2246.  
  2247.           break;
  2248.  
  2249.         case 112:
  2250. /*   BVS,    RELATIVE */
  2251.           {
  2252.         register p1 = LOAD (PC + 1);
  2253.         register unsigned src = p1;
  2254.         register BYTE hb;
  2255.         PC += 2;
  2256.         /* Branch if overflow flag is set. */
  2257.         if (IF_OVERFLOW ())
  2258.           {
  2259.             hb = UPPER (PC);
  2260.             PC = REL_ADDR (PC, src);
  2261.             if (brtest (hb))
  2262.               /* Same page */
  2263.               clkcount = 3;
  2264.             else
  2265.               /* Different page */
  2266.               clkcount = 4;
  2267.           }
  2268.         else
  2269.           clkcount = 2;
  2270.           }
  2271.  
  2272.           break;
  2273.  
  2274.         case 113:
  2275.           {
  2276.         register p1 = LOAD (PC + 1);
  2277.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  2278.         register unsigned src = LOAD (p2 + YR);
  2279.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2280.         PC += 2;
  2281.  
  2282.         if (pagetest (p2, YR))
  2283.           /* Over page */
  2284.           clkcount = 6;
  2285.         else
  2286.           /* Same page */
  2287.           clkcount = 5;
  2288.  
  2289.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2290.  
  2291.         /*
  2292.          * In decimal mode this is "correct" but not exact emulation. However,
  2293.          * the probability of different result when using undefined BCD codes is
  2294.          * less than 6%
  2295.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2296.          */
  2297.  
  2298.         if (IF_DECIMAL ())
  2299.           {
  2300.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2301.               temp += 6;
  2302.  
  2303.             SET_SIGN (temp);
  2304.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2305.  
  2306.             if (temp > 0x99)
  2307.               temp += 96;
  2308.  
  2309.             SET_CARRY (temp > 0x99);
  2310.           }
  2311.         else
  2312.           {
  2313.             SET_SIGN (temp);
  2314.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2315.             SET_CARRY (temp > 0xff);
  2316.           }
  2317.  
  2318.         AC = ((BYTE) temp);
  2319.           }
  2320.  
  2321.           break;
  2322.  
  2323.         case 114:
  2324.           {
  2325.         PC++;
  2326.         /* No such opcode. */
  2327.         (void) printf ("Illegal instruction.\n");
  2328.         verflg = 1;
  2329.         --PC;
  2330.  
  2331.         mon (PC);
  2332.           }
  2333.  
  2334.           break;
  2335.  
  2336.         case 115:
  2337.           {
  2338.         register p1 = LOAD (PC + 1);
  2339.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  2340.         register unsigned int temp;
  2341.         PC += 2;
  2342.  
  2343.  
  2344.         /* src = ror(src); AC = adc(src);
  2345.          * the real operation discovered by msmakela
  2346.          * ADC only does the BCD fixup */
  2347.  
  2348.         temp = src >> 1;    /* ROR+ADC */
  2349.         if (IF_CARRY ())
  2350.           temp |= 0x80;
  2351.  
  2352.         SET_SIGN (temp);
  2353.         SET_ZERO (temp);    /* Set flags like ROR does */
  2354.  
  2355.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2356.  
  2357.         if (IF_DECIMAL ())
  2358.           {
  2359.             if ((src & 0x0f) > 4)    /* half of the normal */
  2360.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2361.             if (src > 0x4f)
  2362.               temp += 96;
  2363.  
  2364.             SET_CARRY (src > 0x4f);
  2365.           }
  2366.         else
  2367.           {
  2368.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2369.           }
  2370.  
  2371.  
  2372.         STORE (LOAD_ZERO_ADDR (p1) + YR, ((BYTE) temp));;
  2373.         clkcount = 8;
  2374.           }
  2375.  
  2376.           break;
  2377.  
  2378.         case 116:
  2379.           {
  2380.         PC += 2;
  2381.  
  2382.         clkcount = 4;
  2383.           }
  2384.  
  2385.           break;
  2386.  
  2387.         case 117:
  2388.           {
  2389.         register p1 = LOAD (PC + 1);
  2390.         register unsigned src = LOAD_ZERO (p1 + XR);
  2391.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2392.         PC += 2;
  2393.  
  2394.  
  2395.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2396.  
  2397.         /*
  2398.          * In decimal mode this is "correct" but not exact emulation. However,
  2399.          * the probability of different result when using undefined BCD codes is
  2400.          * less than 6%
  2401.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2402.          */
  2403.  
  2404.         if (IF_DECIMAL ())
  2405.           {
  2406.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2407.               temp += 6;
  2408.  
  2409.             SET_SIGN (temp);
  2410.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2411.  
  2412.             if (temp > 0x99)
  2413.               temp += 96;
  2414.  
  2415.             SET_CARRY (temp > 0x99);
  2416.           }
  2417.         else
  2418.           {
  2419.             SET_SIGN (temp);
  2420.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2421.             SET_CARRY (temp > 0xff);
  2422.           }
  2423.  
  2424.         AC = ((BYTE) temp);;
  2425.         clkcount = 4;
  2426.           }
  2427.  
  2428.           break;
  2429.  
  2430.         case 118:
  2431.           {
  2432.         register p1 = LOAD (PC + 1);
  2433.         register unsigned src = LOAD_ZERO (p1 + XR);
  2434.         PC += 2;
  2435.  
  2436.         if (IF_CARRY ())
  2437.           src |= 0x100;
  2438.         SET_CARRY (src & 0x01);
  2439.         src >>= 1;
  2440.  
  2441.         SET_SIGN (src);
  2442.         SET_ZERO (src);
  2443.  
  2444.         STORE_ZERO (p1 + XR, (src));;
  2445.         clkcount = 6;
  2446.           }
  2447.  
  2448.           break;
  2449.  
  2450.         case 119:
  2451.           {
  2452.         register p1 = LOAD (PC + 1);
  2453.         register unsigned src = LOAD_ZERO (p1 + XR);
  2454.         register unsigned int temp;
  2455.         PC += 2;
  2456.  
  2457.  
  2458.         /* src = ror(src); AC = adc(src);
  2459.          * the real operation discovered by msmakela
  2460.          * ADC only does the BCD fixup */
  2461.  
  2462.         temp = src >> 1;    /* ROR+ADC */
  2463.         if (IF_CARRY ())
  2464.           temp |= 0x80;
  2465.  
  2466.         SET_SIGN (temp);
  2467.         SET_ZERO (temp);    /* Set flags like ROR does */
  2468.  
  2469.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2470.  
  2471.         if (IF_DECIMAL ())
  2472.           {
  2473.             if ((src & 0x0f) > 4)    /* half of the normal */
  2474.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2475.             if (src > 0x4f)
  2476.               temp += 96;
  2477.  
  2478.             SET_CARRY (src > 0x4f);
  2479.           }
  2480.         else
  2481.           {
  2482.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2483.           }
  2484.  
  2485.  
  2486.         STORE_ZERO (p1 + XR, ((BYTE) temp));;
  2487.         clkcount = 6;
  2488.           }
  2489.  
  2490.           break;
  2491.  
  2492.         case 120:
  2493.           {
  2494.         PC++;
  2495.  
  2496.  
  2497.         SET_INTERRUPT ((1));;
  2498.         clkcount = 2;
  2499.           }
  2500.  
  2501.           break;
  2502.  
  2503.         case 121:
  2504. /*   ADC,    ABSOLUTE_Y */
  2505.           {
  2506.         register p2 = load_abs_addr ();
  2507.         register unsigned src = LOAD (p2 + YR);
  2508.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2509.         PC += 3;
  2510.  
  2511.         if (pagetest (p2, YR))
  2512.           /* Over page */
  2513.           clkcount = 5;
  2514.         else
  2515.           /* Same page */
  2516.           clkcount = 4;
  2517.  
  2518.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2519.  
  2520.         /*
  2521.          * In decimal mode this is "correct" but not exact emulation. However,
  2522.          * the probability of different result when using undefined BCD codes is
  2523.          * less than 6%
  2524.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2525.          */
  2526.  
  2527.         if (IF_DECIMAL ())
  2528.           {
  2529.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2530.               temp += 6;
  2531.  
  2532.             SET_SIGN (temp);
  2533.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2534.  
  2535.             if (temp > 0x99)
  2536.               temp += 96;
  2537.  
  2538.             SET_CARRY (temp > 0x99);
  2539.           }
  2540.         else
  2541.           {
  2542.             SET_SIGN (temp);
  2543.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2544.             SET_CARRY (temp > 0xff);
  2545.           }
  2546.  
  2547.         AC = ((BYTE) temp);
  2548.           }
  2549.  
  2550.           break;
  2551.  
  2552.         case 122:
  2553.           {
  2554.         PC++;
  2555.  
  2556.         clkcount = 2;
  2557.           }
  2558.  
  2559.           break;
  2560.  
  2561.         case 123:
  2562.           {
  2563.         register p2 = load_abs_addr ();
  2564.         register unsigned src = LOAD (p2 + YR);
  2565.         register unsigned int temp;
  2566.         PC += 3;
  2567.  
  2568.  
  2569.         /* src = ror(src); AC = adc(src);
  2570.          * the real operation discovered by msmakela
  2571.          * ADC only does the BCD fixup */
  2572.  
  2573.         temp = src >> 1;    /* ROR+ADC */
  2574.         if (IF_CARRY ())
  2575.           temp |= 0x80;
  2576.  
  2577.         SET_SIGN (temp);
  2578.         SET_ZERO (temp);    /* Set flags like ROR does */
  2579.  
  2580.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2581.  
  2582.         if (IF_DECIMAL ())
  2583.           {
  2584.             if ((src & 0x0f) > 4)    /* half of the normal */
  2585.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2586.             if (src > 0x4f)
  2587.               temp += 96;
  2588.  
  2589.             SET_CARRY (src > 0x4f);
  2590.           }
  2591.         else
  2592.           {
  2593.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2594.           }
  2595.  
  2596.  
  2597.         STORE (p2 + YR, ((BYTE) temp));;
  2598.         clkcount = 7;
  2599.           }
  2600.  
  2601.           break;
  2602.  
  2603.         case 124:
  2604.           {
  2605.         PC += 3;
  2606.  
  2607.         clkcount = 4;
  2608.           }
  2609.  
  2610.           break;
  2611.  
  2612.         case 125:
  2613. /*  ADC,    ABSOLUTE_X */
  2614.           {
  2615.         register p2 = load_abs_addr ();
  2616.         register unsigned src = LOAD (p2 + XR);
  2617.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2618.         PC += 3;
  2619.  
  2620.         if (pagetest (p2, XR))
  2621.           /* Over page */
  2622.           clkcount = 5;
  2623.         else
  2624.           /* Same page */
  2625.           clkcount = 4;
  2626.  
  2627.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2628.  
  2629.         /*
  2630.          * In decimal mode this is "correct" but not exact emulation. However,
  2631.          * the probability of different result when using undefined BCD codes is
  2632.          * less than 6%
  2633.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2634.          */
  2635.  
  2636.         if (IF_DECIMAL ())
  2637.           {
  2638.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2639.               temp += 6;
  2640.  
  2641.             SET_SIGN (temp);
  2642.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2643.  
  2644.             if (temp > 0x99)
  2645.               temp += 96;
  2646.  
  2647.             SET_CARRY (temp > 0x99);
  2648.           }
  2649.         else
  2650.           {
  2651.             SET_SIGN (temp);
  2652.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2653.             SET_CARRY (temp > 0xff);
  2654.           }
  2655.  
  2656.         AC = ((BYTE) temp);
  2657.           }
  2658.  
  2659.           break;
  2660.  
  2661.         case 126:
  2662.           {
  2663.         register p2 = load_abs_addr ();
  2664.         register unsigned src = LOAD (p2 + XR);
  2665.         PC += 3;
  2666.  
  2667.         if (IF_CARRY ())
  2668.           src |= 0x100;
  2669.         SET_CARRY (src & 0x01);
  2670.         src >>= 1;
  2671.  
  2672.         SET_SIGN (src);
  2673.         SET_ZERO (src);
  2674.  
  2675.         STORE (p2 + XR, (src));;
  2676.         clkcount = 7;
  2677.           }
  2678.  
  2679.           break;
  2680.  
  2681.         case 127:
  2682.           {
  2683.         register p2 = load_abs_addr ();
  2684.         register unsigned src = LOAD (p2 + XR);
  2685.         register unsigned int temp;
  2686.         PC += 3;
  2687.  
  2688.  
  2689.         /* src = ror(src); AC = adc(src);
  2690.          * the real operation discovered by msmakela
  2691.          * ADC only does the BCD fixup */
  2692.  
  2693.         temp = src >> 1;    /* ROR+ADC */
  2694.         if (IF_CARRY ())
  2695.           temp |= 0x80;
  2696.  
  2697.         SET_SIGN (temp);
  2698.         SET_ZERO (temp);    /* Set flags like ROR does */
  2699.  
  2700.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2701.  
  2702.         if (IF_DECIMAL ())
  2703.           {
  2704.             if ((src & 0x0f) > 4)    /* half of the normal */
  2705.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2706.             if (src > 0x4f)
  2707.               temp += 96;
  2708.  
  2709.             SET_CARRY (src > 0x4f);
  2710.           }
  2711.         else
  2712.           {
  2713.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2714.           }
  2715.  
  2716.  
  2717.         STORE (p2 + XR, ((BYTE) temp));;
  2718.         clkcount = 7;
  2719.           }
  2720.  
  2721.           break;
  2722.  
  2723.         case 128:
  2724.           {
  2725.         PC += 2;
  2726.  
  2727.         clkcount = 2;
  2728.           }
  2729.  
  2730.           break;
  2731.  
  2732.         case 129:
  2733.           {
  2734.         register p1 = LOAD (PC + 1);
  2735.         register unsigned src = AC;
  2736.         PC += 2;
  2737.  
  2738.  
  2739.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  2740.         clkcount = 6;
  2741.           }
  2742.  
  2743.           break;
  2744.  
  2745.         case 130:
  2746.           {
  2747.         PC += 2;
  2748.  
  2749.         clkcount = 2;
  2750.           }
  2751.  
  2752.           break;
  2753.  
  2754.         case 131:
  2755.           {
  2756.         register p1 = LOAD (PC + 1);
  2757.         register unsigned src = (AC & XR);
  2758.         PC += 2;
  2759.  
  2760.  
  2761.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  2762.         clkcount = 6;
  2763.           }
  2764.  
  2765.           break;
  2766.  
  2767.         case 132:
  2768. /*  STY,    ZERO_PAGE */
  2769.           {
  2770.         register p1 = LOAD (PC + 1);
  2771.         register unsigned src = YR;
  2772.  
  2773.         clkcount = 3;
  2774.         PC += 2;
  2775.  
  2776.         beamadj = BEAMNINE;
  2777.         STORE_ZERO (p1, (src));
  2778.           }
  2779.  
  2780.           break;
  2781.  
  2782.         case 133:
  2783. /*   STA,    ZERO_PAGE */
  2784.           {
  2785.         register p1 = LOAD (PC + 1);
  2786.         register unsigned src = AC;
  2787.  
  2788.         clkcount = 3;
  2789.         PC += 2;
  2790.  
  2791.         beamadj = BEAMNINE;
  2792.         STORE_ZERO (p1, (src));
  2793.           }
  2794.  
  2795.           break;
  2796.  
  2797.         case 134:
  2798. /*  STX,    ZERO_PAGE */
  2799.           {
  2800.         register p1 = LOAD (PC + 1);
  2801.         register unsigned src = XR;
  2802.  
  2803.         clkcount = 3;
  2804.         PC += 2;
  2805.  
  2806.         beamadj = BEAMNINE;
  2807.         STORE_ZERO (p1, (src));
  2808.           }
  2809.  
  2810.           break;
  2811.  
  2812.         case 135:
  2813.           {
  2814.         register p1 = LOAD (PC + 1);
  2815.         register unsigned src = (AC & XR);
  2816.         PC += 2;
  2817.  
  2818.  
  2819.         STORE_ZERO (p1, (src));;
  2820.         clkcount = 3;
  2821.           }
  2822.  
  2823.           break;
  2824.  
  2825.         case 136:
  2826.           {
  2827.         register unsigned src = YR;
  2828.         PC++;
  2829.  
  2830.         src = (src - 1) & 0xff;
  2831.         SET_SIGN (src);
  2832.         SET_ZERO (src);
  2833.  
  2834.         YR = (src);;
  2835.         clkcount = 2;
  2836.           }
  2837.  
  2838.           break;
  2839.  
  2840.         case 137:
  2841.           {
  2842.         PC += 2;
  2843.  
  2844.         clkcount = 2;
  2845.           }
  2846.  
  2847.           break;
  2848.  
  2849.         case 138:
  2850.           {
  2851.         register unsigned src = XR;
  2852.         PC++;
  2853.  
  2854.         SET_SIGN (src);
  2855.         SET_ZERO (src);
  2856.  
  2857.         AC = (src);;
  2858.         clkcount = 2;
  2859.           }
  2860.  
  2861.           break;
  2862.  
  2863.         case 139:
  2864.           {
  2865.         register p1 = LOAD (PC + 1);
  2866.         register unsigned src = ((AC | 0xee) & XR & p1);
  2867.         PC += 2;
  2868.  
  2869.         SET_SIGN (src);
  2870.         SET_ZERO (src);
  2871.  
  2872.         AC = (src);;
  2873.         clkcount = 2;
  2874.           }
  2875.  
  2876.           break;
  2877.  
  2878.         case 140:
  2879. /*  STY,    ABSOLUTE */
  2880.           {
  2881.         register p2 = load_abs_addr ();
  2882.         register unsigned src = YR;
  2883.         PC += 3;
  2884.  
  2885.         beamadj = BEAMTWELVE;
  2886.         STORE (p2, (src));;
  2887.         clkcount = 4;
  2888.           }
  2889.  
  2890.           break;
  2891.  
  2892.         case 141:
  2893. /*  STA,    ABSOLUTE */
  2894.           {
  2895.         register p2 = load_abs_addr ();
  2896.         register unsigned src = AC;
  2897.         PC += 3;
  2898.  
  2899.         beamadj = BEAMTWELVE;
  2900.         STORE (p2, (src));;
  2901.         clkcount = 4;
  2902.           }
  2903.  
  2904.           break;
  2905.  
  2906.         case 142:
  2907. /*  STA,    ABSOLUTE */
  2908.           {
  2909.         register p2 = load_abs_addr ();
  2910.         register unsigned src = XR;
  2911.         PC += 3;
  2912.  
  2913.         beamadj = BEAMTWELVE;
  2914.         STORE (p2, (src));;
  2915.         clkcount = 4;
  2916.           }
  2917.  
  2918.           break;
  2919.  
  2920.         case 143:
  2921. /* STX,    ABSOLUTE */
  2922.           {
  2923.         register p2 = load_abs_addr ();
  2924.         register unsigned src = (AC & XR);
  2925.         PC += 3;
  2926.  
  2927.         beamadj = BEAMTWELVE;
  2928.         STORE (p2, (src));;
  2929.         clkcount = 4;
  2930.           }
  2931.  
  2932.           break;
  2933.  
  2934.         case 144:
  2935. /*  BCC,    RELATIVE */
  2936.           {
  2937.         register p1 = LOAD (PC + 1);
  2938.         register hb;
  2939.         register unsigned src = p1;
  2940.         PC += 2;
  2941.         /* Branch if carry flag is clear. */
  2942.         if (!IF_CARRY ())
  2943.           {
  2944.             hb = UPPER (PC);
  2945.             PC = REL_ADDR (PC, src);
  2946.             if (brtest (hb))
  2947.               /* Same page */
  2948.               clkcount = 3;
  2949.             else
  2950.               /* Different page */
  2951.               clkcount = 4;
  2952.           }
  2953.         else
  2954.           clkcount = 2;
  2955.           }
  2956.  
  2957.           break;
  2958.  
  2959.         case 145:
  2960.           {
  2961.         register p1 = LOAD (PC + 1);
  2962.         register unsigned src = AC;
  2963.         PC += 2;
  2964.  
  2965.  
  2966.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  2967.         clkcount = 6;
  2968.           }
  2969.  
  2970.           break;
  2971.  
  2972.         case 146:
  2973.           {
  2974.         PC++;
  2975.         /* No such opcode. */
  2976.         (void) printf ("Illegal instruction.\n");
  2977.         verflg = 1;
  2978.         --PC;
  2979.  
  2980.         mon (PC);
  2981.           }
  2982.  
  2983.           break;
  2984.  
  2985.         case 147:
  2986.           {
  2987.         register p1 = LOAD (PC + 1);
  2988.         register unsigned src = (AC & XR);
  2989.         PC += 2;
  2990.  
  2991.  
  2992.         u_stoshr (src, LOAD_ZERO_ADDR (p1), YR);;
  2993.         clkcount = 6;
  2994.           }
  2995.  
  2996.           break;
  2997.  
  2998.         case 148:
  2999.           {
  3000.         register p1 = LOAD (PC + 1);
  3001.         register unsigned src = YR;
  3002.         clkcount = 4;
  3003.         PC += 2;
  3004.  
  3005.         beamadj = BEAMTWELVE;
  3006.         STORE_ZERO (p1 + XR, (src));
  3007.           }
  3008.  
  3009.           break;
  3010.  
  3011.         case 149:
  3012. /*  STA,    ZERO_PAGE_X */
  3013.           {
  3014.         register p1 = LOAD (PC + 1);
  3015.         register unsigned src = AC;
  3016.         clkcount = 4;
  3017.         PC += 2;
  3018.  
  3019.         beamadj = BEAMTWELVE;
  3020.         STORE_ZERO (p1 + XR, (src));
  3021.           }
  3022.  
  3023.           break;
  3024.  
  3025.         case 150:
  3026. /* STX,    ZERO_PAGE_Y */
  3027.           {
  3028.         register p1 = LOAD (PC + 1);
  3029.         register unsigned src = XR;
  3030.         clkcount = 4;
  3031.         PC += 2;
  3032.  
  3033.         beamadj = BEAMTWELVE;
  3034.         STORE_ZERO (p1 + YR, (src));
  3035.           }
  3036.  
  3037.           break;
  3038.  
  3039.         case 151:
  3040.           {
  3041.         register p1 = LOAD (PC + 1);
  3042.         register unsigned src = (AC & XR);
  3043.         PC += 2;
  3044.  
  3045.  
  3046.         STORE_ZERO (p1 + YR, (src));;
  3047.         clkcount = 4;
  3048.           }
  3049.  
  3050.           break;
  3051.  
  3052.         case 152:
  3053.           {
  3054.         register unsigned src = YR;
  3055.         PC++;
  3056.  
  3057.         SET_SIGN (src);
  3058.         SET_ZERO (src);
  3059.  
  3060.         AC = (src);;
  3061.         clkcount = 2;
  3062.           }
  3063.  
  3064.           break;
  3065.  
  3066.         case 153:
  3067.           {
  3068.         register p2 = load_abs_addr ();
  3069.         register unsigned src = AC;
  3070.         PC += 3;
  3071.  
  3072.  
  3073.         STORE (p2 + YR, (src));;
  3074.         clkcount = 5;
  3075.           }
  3076.  
  3077.           break;
  3078.  
  3079.         case 154:
  3080.           {
  3081.         register unsigned src = XR;
  3082.         PC++;
  3083.  
  3084.  
  3085.         SP = (src);;
  3086.         clkcount = 2;
  3087.           }
  3088.  
  3089.           break;
  3090.  
  3091.         case 155:
  3092.           {
  3093.         register unsigned src = (AC & XR);
  3094.         PC += 3;
  3095.  
  3096.  
  3097.         SP = src; /* SHS */ ;
  3098.         clkcount = 5;
  3099.           }
  3100.  
  3101.           break;
  3102.  
  3103.         case 156:
  3104.           {
  3105.         register p2 = load_abs_addr ();
  3106.         register unsigned src = YR;
  3107.         PC += 3;
  3108.  
  3109.  
  3110.         u_stoshr (src, p2, XR);;
  3111.         clkcount = 5;
  3112.           }
  3113.  
  3114.           break;
  3115.  
  3116.         case 157:
  3117.           {
  3118.         register p2 = load_abs_addr ();
  3119.         register unsigned src = AC;
  3120.         PC += 3;
  3121.  
  3122.  
  3123.         STORE (p2 + XR, (src));;
  3124.         clkcount = 5;
  3125.           }
  3126.  
  3127.           break;
  3128.  
  3129.         case 158:
  3130.           {
  3131.         register p2 = load_abs_addr ();
  3132.         register unsigned src = XR;
  3133.         PC += 3;
  3134.  
  3135.  
  3136.         u_stoshr (src, p2, YR);;
  3137.         clkcount = 5;
  3138.           }
  3139.  
  3140.           break;
  3141.  
  3142.         case 159:
  3143.           {
  3144.         register p2 = load_abs_addr ();
  3145.         register unsigned src = (AC & XR);
  3146.         PC += 3;
  3147.  
  3148.  
  3149.         u_stoshr (src, p2, YR);;
  3150.         clkcount = 5;
  3151.           }
  3152.  
  3153.           break;
  3154.  
  3155.         case 160:
  3156.           {
  3157.         register p1 = LOAD (PC + 1);
  3158.         register unsigned src = p1;
  3159.         PC += 2;
  3160.  
  3161.         SET_SIGN (src);
  3162.         SET_ZERO (src);
  3163.  
  3164.         YR = (src);;
  3165.         clkcount = 2;
  3166.           }
  3167.  
  3168.           break;
  3169.  
  3170.         case 161:
  3171.           {
  3172.         register p1 = LOAD (PC + 1);
  3173.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3174.         PC += 2;
  3175.  
  3176.         SET_SIGN (src);
  3177.         SET_ZERO (src);
  3178.  
  3179.         AC = (src);;
  3180.         clkcount = 6;
  3181.           }
  3182.  
  3183.           break;
  3184.  
  3185.         case 162:
  3186.           {
  3187.         register p1 = LOAD (PC + 1);
  3188.         register unsigned src = p1;
  3189.         PC += 2;
  3190.  
  3191.         SET_SIGN (src);
  3192.         SET_ZERO (src);
  3193.  
  3194.         XR = (src);;
  3195.         clkcount = 2;
  3196.           }
  3197.  
  3198.           break;
  3199.  
  3200.         case 163:
  3201.           {
  3202.         register p1 = LOAD (PC + 1);
  3203.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3204.         PC += 2;
  3205.  
  3206.         SET_SIGN (src);
  3207.         SET_ZERO (src);
  3208.  
  3209.         AC = XR = (src);;
  3210.         clkcount = 6;
  3211.           }
  3212.  
  3213.           break;
  3214.  
  3215.         case 164:
  3216.           {
  3217.         register p1 = LOAD (PC + 1);
  3218.         register unsigned src = LOAD_ZERO (p1);
  3219.         PC += 2;
  3220.  
  3221.         SET_SIGN (src);
  3222.         SET_ZERO (src);
  3223.  
  3224.         YR = (src);;
  3225.         clkcount = 3;
  3226.           }
  3227.  
  3228.           break;
  3229.  
  3230.         case 165:
  3231.           {
  3232.         register p1 = LOAD (PC + 1);
  3233.         register unsigned src = LOAD_ZERO (p1);
  3234.         PC += 2;
  3235.  
  3236.         SET_SIGN (src);
  3237.         SET_ZERO (src);
  3238.  
  3239.         AC = (src);;
  3240.         clkcount = 3;
  3241.           }
  3242.  
  3243.           break;
  3244.  
  3245.         case 166:
  3246. /*      LDX,   ZERO_PAGE */
  3247.           {
  3248.         register p1 = LOADEXEC (PC + 1);
  3249.         register unsigned src = LOAD_ZERO (p1);
  3250.  
  3251.         clkcount = 3;
  3252.         PC += 2;
  3253.  
  3254.         SET_SIGN (src);
  3255.         SET_ZERO (src);
  3256.  
  3257.         XR = (src);
  3258.           }
  3259.  
  3260.           break;
  3261.  
  3262.         case 167:
  3263.           {
  3264.         register p1 = LOAD (PC + 1);
  3265.         register unsigned src = LOAD_ZERO (p1);
  3266.         PC += 2;
  3267.  
  3268.         SET_SIGN (src);
  3269.         SET_ZERO (src);
  3270.  
  3271.         AC = XR = (src);;
  3272.         clkcount = 3;
  3273.           }
  3274.  
  3275.           break;
  3276.  
  3277.         case 168:
  3278.           {
  3279.         register unsigned src = AC;
  3280.         PC++;
  3281.  
  3282.         SET_SIGN (src);
  3283.         SET_ZERO (src);
  3284.  
  3285.         YR = (src);;
  3286.         clkcount = 2;
  3287.           }
  3288.  
  3289.           break;
  3290.  
  3291.         case 169:
  3292.           {
  3293.         register p1 = LOAD (PC + 1);
  3294.         register unsigned src = p1;
  3295.         PC += 2;
  3296.  
  3297.         SET_SIGN (src);
  3298.         SET_ZERO (src);
  3299.  
  3300.         AC = (src);;
  3301.         clkcount = 2;
  3302.           }
  3303.  
  3304.           break;
  3305.  
  3306.         case 170:
  3307.           {
  3308.         register unsigned src = AC;
  3309.         PC++;
  3310.  
  3311.         SET_SIGN (src);
  3312.         SET_ZERO (src);
  3313.  
  3314.         XR = (src);;
  3315.         clkcount = 2;
  3316.           }
  3317.  
  3318.           break;
  3319.  
  3320.         case 171:
  3321.           {
  3322.         register p1 = LOAD (PC + 1);
  3323.         register unsigned src = (AC & p1);
  3324.         PC += 2;
  3325.  
  3326.         SET_SIGN (src);
  3327.         SET_ZERO (src);
  3328.  
  3329.         AC = XR = (src);;
  3330.         clkcount = 2;
  3331.           }
  3332.  
  3333.           break;
  3334.  
  3335.         case 172:
  3336.           {
  3337.         register p2 = load_abs_addr ();
  3338.         register unsigned src = LOAD (p2);
  3339.         PC += 3;
  3340.  
  3341.         SET_SIGN (src);
  3342.         SET_ZERO (src);
  3343.  
  3344.         YR = (src);;
  3345.         clkcount = 4;
  3346.           }
  3347.  
  3348.           break;
  3349.  
  3350.         case 173:        /* LDA absolute */
  3351.           {
  3352.         register p2 = load_abs_addr ();
  3353.         register unsigned src;
  3354.         clkcount = 4;
  3355.         src = LOAD (p2);
  3356.         PC += 3;
  3357.  
  3358.         SET_SIGN (src);
  3359.         SET_ZERO (src);
  3360.  
  3361.         AC = (src);
  3362.           }
  3363.  
  3364.           break;
  3365.  
  3366.         case 174:
  3367.           {
  3368.         register p2 = load_abs_addr ();
  3369.         register unsigned src = LOAD (p2);
  3370.         PC += 3;
  3371.  
  3372.         SET_SIGN (src);
  3373.         SET_ZERO (src);
  3374.  
  3375.         XR = (src);;
  3376.         clkcount = 4;
  3377.           }
  3378.  
  3379.           break;
  3380.  
  3381.         case 175:
  3382.           {
  3383.         register p2 = load_abs_addr ();
  3384.         register unsigned src = LOAD (p2);
  3385.         PC += 3;
  3386.  
  3387.         SET_SIGN (src);
  3388.         SET_ZERO (src);
  3389.  
  3390.         AC = XR = (src);;
  3391.         clkcount = 4;
  3392.           }
  3393.  
  3394.           break;
  3395.  
  3396.         case 176:
  3397. /*   BCS,    RELATIVE */
  3398.           {
  3399.         register p1 = LOAD (PC + 1);
  3400.         register unsigned src = p1;
  3401.         register BYTE hb;
  3402.         PC += 2;
  3403.         /* Branch if carry flag is set. */
  3404.         if (IF_CARRY ())
  3405.           {
  3406.             hb = UPPER (PC);
  3407.             PC = REL_ADDR (PC, src);
  3408.             if (brtest (hb))
  3409.               /* Same page */
  3410.               clkcount = 3;
  3411.             else
  3412.               /* Different page */
  3413.               clkcount = 4;
  3414.           }
  3415.         else
  3416.           clkcount = 2;
  3417.           }
  3418.  
  3419.           break;
  3420.  
  3421.         case 177:
  3422. /*   LDA,    INDIRECT_Y */
  3423.           {
  3424.         register p1 = LOAD (PC + 1);
  3425.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3426.         register unsigned src = LOAD (p2 + YR);
  3427.         PC += 2;
  3428.  
  3429.         if (pagetest (p2, YR))
  3430.           /* Over page */
  3431.           clkcount = 6;
  3432.         else
  3433.           /* Same page */
  3434.           clkcount = 5;
  3435.  
  3436.         SET_SIGN (src);
  3437.         SET_ZERO (src);
  3438.  
  3439.         AC = (src);
  3440.           }
  3441.  
  3442.           break;
  3443.  
  3444.         case 178:
  3445.           {
  3446.         PC++;
  3447.         /* No such opcode. */
  3448.         (void) printf ("Illegal instruction.\n");
  3449.         verflg = 1;
  3450.         --PC;
  3451.  
  3452.         mon (PC);
  3453.           }
  3454.  
  3455.           break;
  3456.  
  3457.         case 179:
  3458. /*   LAX,    INDIRECT_Y */
  3459.           {
  3460.         register p1 = LOAD (PC + 1);
  3461.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3462.         register unsigned src = LOAD (p2 + YR);
  3463.         PC += 2;
  3464.         if (pagetest (p2, YR))
  3465.           /* Over page */
  3466.           clkcount = 6;
  3467.         else
  3468.           /* Same page */
  3469.           clkcount = 5;
  3470.  
  3471.         SET_SIGN (src);
  3472.         SET_ZERO (src);
  3473.  
  3474.         AC = XR = (src);
  3475.           }
  3476.  
  3477.           break;
  3478.  
  3479.         case 180:
  3480.           {
  3481.         register p1 = LOAD (PC + 1);
  3482.         register unsigned src = LOAD_ZERO (p1 + XR);
  3483.         PC += 2;
  3484.  
  3485.         SET_SIGN (src);
  3486.         SET_ZERO (src);
  3487.  
  3488.         YR = (src);;
  3489.         clkcount = 4;
  3490.           }
  3491.  
  3492.           break;
  3493.  
  3494.         case 181:
  3495.           {
  3496.         register p1 = LOAD (PC + 1);
  3497.         register unsigned src = LOAD_ZERO (p1 + XR);
  3498.         PC += 2;
  3499.  
  3500.         SET_SIGN (src);
  3501.         SET_ZERO (src);
  3502.  
  3503.         AC = (src);;
  3504.         clkcount = 4;
  3505.           }
  3506.  
  3507.           break;
  3508.  
  3509.         case 182:
  3510.           {
  3511.         register p1 = LOAD (PC + 1);
  3512.         register unsigned src = LOAD_ZERO (p1 + YR);
  3513.         PC += 2;
  3514.  
  3515.         SET_SIGN (src);
  3516.         SET_ZERO (src);
  3517.  
  3518.         XR = (src);;
  3519.         clkcount = 4;
  3520.           }
  3521.  
  3522.           break;
  3523.  
  3524.         case 183:
  3525.           {
  3526.         register p1 = LOAD (PC + 1);
  3527.         register unsigned src = LOAD_ZERO (p1 + YR);
  3528.         PC += 2;
  3529.  
  3530.         SET_SIGN (src);
  3531.         SET_ZERO (src);
  3532.  
  3533.         AC = XR = (src);;
  3534.         clkcount = 4;
  3535.           }
  3536.  
  3537.           break;
  3538.  
  3539.         case 184:
  3540.           {
  3541.         PC++;
  3542.  
  3543.  
  3544.         SET_OVERFLOW ((0));;
  3545.         clkcount = 2;
  3546.           }
  3547.  
  3548.           break;
  3549.  
  3550.         case 185:
  3551.           {
  3552.         register p2 = load_abs_addr ();
  3553.         register unsigned src = LOAD (p2 + YR);
  3554.         PC += 3;
  3555.         if (pagetest (p2, YR))
  3556.           /* Over page */
  3557.           clkcount = 5;
  3558.         else
  3559.           /* Same page */
  3560.           clkcount = 4;
  3561.  
  3562.         SET_SIGN (src);
  3563.         SET_ZERO (src);
  3564.  
  3565.         AC = (src);
  3566.           }
  3567.  
  3568.           break;
  3569.  
  3570.         case 186:
  3571.           {
  3572.         register unsigned src = SP;
  3573.         PC++;
  3574.  
  3575.         SET_SIGN (src);
  3576.         SET_ZERO (src);
  3577.  
  3578.         XR = (src);;
  3579.         clkcount = 2;
  3580.           }
  3581.  
  3582.           break;
  3583.  
  3584.         case 187:
  3585.           {
  3586.         register p2 = load_abs_addr ();
  3587.         register unsigned src = (SP & LOAD (p2 + YR));
  3588.         PC += 3;
  3589.         if (pagetest (p2, YR))
  3590.           /* Over page */
  3591.           clkcount = 5;
  3592.         else
  3593.           /* Same page */
  3594.           clkcount = 4;
  3595.  
  3596.         SET_SIGN (src);
  3597.         SET_ZERO (src);
  3598.  
  3599.         AC = XR = SP = (src);
  3600.           }
  3601.  
  3602.           break;
  3603.  
  3604.         case 188:
  3605. /*   LDY,    ABSOLUTE_X */
  3606.           {
  3607.         register p2 = load_abs_addr ();
  3608.         register unsigned src = LOAD (p2 + XR);
  3609.         PC += 3;
  3610.         if (pagetest (p2, XR))
  3611.           /* Over page */
  3612.           clkcount = 5;
  3613.         else
  3614.           /* Same page */
  3615.           clkcount = 4;
  3616.  
  3617.  
  3618.         SET_SIGN (src);
  3619.         SET_ZERO (src);
  3620.  
  3621.         YR = (src);
  3622.           }
  3623.  
  3624.           break;
  3625.  
  3626.         case 189:
  3627. /*  LDA,    ABSOLUTE_X */
  3628.           {
  3629.         register p2 = load_abs_addr ();
  3630.         register unsigned src = LOAD (p2 + XR);
  3631.         PC += 3;
  3632.  
  3633.         if (pagetest (p2, XR))
  3634.           /* Over page */
  3635.           clkcount = 5;
  3636.         else
  3637.           /* Same page */
  3638.           clkcount = 4;
  3639.  
  3640.         SET_SIGN (src);
  3641.         SET_ZERO (src);
  3642.  
  3643.         AC = (src);
  3644.           }
  3645.  
  3646.           break;
  3647.  
  3648.         case 190:
  3649. /*   LDX,    ABSOLUTE_Y */
  3650.           {
  3651.         register p2 = load_abs_addr ();
  3652.         register unsigned src = LOAD (p2 + YR);
  3653.         PC += 3;
  3654.         if (pagetest (p2, YR))
  3655.           /* Over page */
  3656.           clkcount = 5;
  3657.         else
  3658.           /* Same page */
  3659.           clkcount = 4;
  3660.  
  3661.         SET_SIGN (src);
  3662.         SET_ZERO (src);
  3663.  
  3664.         XR = (src);
  3665.           }
  3666.  
  3667.           break;
  3668.  
  3669.         case 191:
  3670. /*   LAX,    ABSOLUTE_Y */
  3671.           {
  3672.         register p2 = load_abs_addr ();
  3673.         register unsigned src = LOAD (p2 + YR);
  3674.         PC += 3;
  3675.         if (pagetest (p2, YR))
  3676.           /* Over page */
  3677.           clkcount = 5;
  3678.         else
  3679.           /* Same page */
  3680.           clkcount = 4;
  3681.  
  3682.         SET_SIGN (src);
  3683.         SET_ZERO (src);
  3684.  
  3685.         AC = XR = (src);
  3686.           }
  3687.  
  3688.           break;
  3689.  
  3690.         case 192:
  3691.           {
  3692.         register p1 = LOAD (PC + 1);
  3693.         register unsigned src = p1;
  3694.         PC += 2;
  3695.  
  3696.         src = YR - src;
  3697.         SET_CARRY (src < 0x100);
  3698.         SET_SIGN (src);
  3699.         SET_ZERO (src &= 0xff);
  3700.         clkcount = 2;
  3701.           }
  3702.  
  3703.           break;
  3704.  
  3705.         case 193:
  3706.           {
  3707.         register p1 = LOAD (PC + 1);
  3708.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3709.         PC += 2;
  3710.  
  3711.         src = AC - src;
  3712.         SET_CARRY (src < 0x100);
  3713.         SET_SIGN (src);
  3714.         SET_ZERO (src &= 0xff);
  3715.         clkcount = 6;
  3716.           }
  3717.  
  3718.           break;
  3719.  
  3720.         case 194:
  3721.           {
  3722.         PC += 2;
  3723.  
  3724.         clkcount = 2;
  3725.           }
  3726.  
  3727.           break;
  3728.  
  3729.         case 195:
  3730.           {
  3731.         register p1 = LOAD (PC + 1);
  3732.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3733.         PC += 2;
  3734.  
  3735.         /* cmp(--src & 0xff));  */
  3736.  
  3737.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3738.         SET_CARRY (AC >= src);
  3739.         SET_SIGN (AC - src);
  3740.         SET_ZERO (AC != src);
  3741.  
  3742.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  3743.         clkcount = 8;
  3744.           }
  3745.  
  3746.           break;
  3747.  
  3748.         case 196:
  3749.           {
  3750.         register p1 = LOAD (PC + 1);
  3751.         register unsigned src = LOAD_ZERO (p1);
  3752.         PC += 2;
  3753.  
  3754.         src = YR - src;
  3755.         SET_CARRY (src < 0x100);
  3756.         SET_SIGN (src);
  3757.         SET_ZERO (src &= 0xff);
  3758.         clkcount = 3;
  3759.           }
  3760.  
  3761.           break;
  3762.  
  3763.         case 197:
  3764.           {
  3765.         register p1 = LOAD (PC + 1);
  3766.         register unsigned src = LOAD_ZERO (p1);
  3767.         PC += 2;
  3768.  
  3769.         src = AC - src;
  3770.         SET_CARRY (src < 0x100);
  3771.         SET_SIGN (src);
  3772.         SET_ZERO (src &= 0xff);
  3773.         clkcount = 3;
  3774.           }
  3775.  
  3776.           break;
  3777.  
  3778.         case 198:
  3779.           {
  3780.         register p1 = LOAD (PC + 1);
  3781.         register unsigned src = LOAD_ZERO (p1);
  3782.         PC += 2;
  3783.  
  3784.         src = (src - 1) & 0xff;
  3785.         SET_SIGN (src);
  3786.         SET_ZERO (src);
  3787.  
  3788.         STORE_ZERO (p1, (src));;
  3789.         clkcount = 5;
  3790.           }
  3791.  
  3792.           break;
  3793.  
  3794.         case 199:
  3795.           {
  3796.         register p1 = LOAD (PC + 1);
  3797.         register unsigned src = LOAD_ZERO (p1);
  3798.         PC += 2;
  3799.  
  3800.         /* cmp(--src & 0xff));  */
  3801.  
  3802.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3803.         SET_CARRY (AC >= src);
  3804.         SET_SIGN (AC - src);
  3805.         SET_ZERO (AC != src);
  3806.  
  3807.         STORE_ZERO (p1, (src));;
  3808.         clkcount = 5;
  3809.           }
  3810.  
  3811.           break;
  3812.  
  3813.         case 200:
  3814.           {
  3815.         register unsigned src = YR;
  3816.         PC++;
  3817.  
  3818.         src = (src + 1) & 0xff;
  3819.         SET_SIGN (src);
  3820.         SET_ZERO (src);
  3821.  
  3822.         YR = (src);;
  3823.         clkcount = 2;
  3824.           }
  3825.  
  3826.           break;
  3827.  
  3828.         case 201:
  3829.           {
  3830.         register p1 = LOAD (PC + 1);
  3831.         register unsigned src = p1;
  3832.         PC += 2;
  3833.  
  3834.         src = AC - src;
  3835.         SET_CARRY (src < 0x100);
  3836.         SET_SIGN (src);
  3837.         SET_ZERO (src &= 0xff);
  3838.         clkcount = 2;
  3839.           }
  3840.  
  3841.           break;
  3842.  
  3843.         case 202:
  3844.           {
  3845.         register unsigned src = XR;
  3846.         PC++;
  3847.  
  3848.         src = (src - 1) & 0xff;
  3849.         SET_SIGN (src);
  3850.         SET_ZERO (src);
  3851.  
  3852.         XR = (src);;
  3853.         clkcount = 2;
  3854.           }
  3855.  
  3856.           break;
  3857.  
  3858.         case 203:
  3859.           {
  3860.         register p1 = LOAD (PC + 1);
  3861.         register unsigned src = p1;
  3862.         PC += 2;
  3863.  
  3864.         src = (AC & XR) - src;    /* Carry is ignored (CMP) */
  3865.         /* Overflow flag may be affected */
  3866.         SET_CARRY (src < 0x100);
  3867.  
  3868.         src &= 0xff;    /* No decimal mode */
  3869.         SET_SIGN (src);
  3870.         SET_ZERO (src);
  3871.  
  3872.         XR = (src);;
  3873.         clkcount = 2;
  3874.           }
  3875.  
  3876.           break;
  3877.  
  3878.         case 204:
  3879.           {
  3880.         register p2 = load_abs_addr ();
  3881.         register unsigned src = LOAD (p2);
  3882.         PC += 3;
  3883.  
  3884.         src = YR - src;
  3885.         SET_CARRY (src < 0x100);
  3886.         SET_SIGN (src);
  3887.         SET_ZERO (src &= 0xff);
  3888.         clkcount = 4;
  3889.           }
  3890.  
  3891.           break;
  3892.  
  3893.         case 205:
  3894.           {
  3895.         register p2 = load_abs_addr ();
  3896.         register unsigned src = LOAD (p2);
  3897.         PC += 3;
  3898.  
  3899.         src = AC - src;
  3900.         SET_CARRY (src < 0x100);
  3901.         SET_SIGN (src);
  3902.         SET_ZERO (src &= 0xff);
  3903.         clkcount = 4;
  3904.           }
  3905.  
  3906.           break;
  3907.  
  3908.         case 206:
  3909.           {
  3910.         register p2 = load_abs_addr ();
  3911.         register unsigned src = LOAD (p2);
  3912.         PC += 3;
  3913.  
  3914.         src = (src - 1) & 0xff;
  3915.         SET_SIGN (src);
  3916.         SET_ZERO (src);
  3917.  
  3918.         STORE (p2, (src));;
  3919.         clkcount = 6;
  3920.           }
  3921.  
  3922.           break;
  3923.  
  3924.         case 207:
  3925.           {
  3926.         register p2 = load_abs_addr ();
  3927.         register unsigned src = LOAD (p2);
  3928.         PC += 3;
  3929.  
  3930.         /* cmp(--src & 0xff));  */
  3931.  
  3932.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3933.         SET_CARRY (AC >= src);
  3934.         SET_SIGN (AC - src);
  3935.         SET_ZERO (AC != src);
  3936.  
  3937.         STORE (p2, (src));;
  3938.         clkcount = 6;
  3939.           }
  3940.  
  3941.           break;
  3942.  
  3943.         case 208:
  3944. /*  BNE,    RELATIVE */
  3945.           {
  3946.         register p1 = LOAD (PC + 1);
  3947.         register unsigned src = p1;
  3948.         register BYTE hb;
  3949.         PC += 2;
  3950.         /* Branch if  zero flag is clear. */
  3951.         if (!IF_ZERO ())
  3952.           {
  3953.             hb = UPPER (PC);
  3954.             PC = REL_ADDR (PC, src);
  3955.             if (brtest (hb))
  3956.               /* Same page */
  3957.               clkcount = 3;
  3958.             else
  3959.               /* Different page */
  3960.               clkcount = 4;
  3961.           }
  3962.         else
  3963.           clkcount = 2;
  3964.           }
  3965.  
  3966.           break;
  3967.  
  3968.         case 209:
  3969. /*   CMP,    INDIRECT_Y */
  3970.           {
  3971.         register p1 = LOAD (PC + 1);
  3972.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3973.         register unsigned src = LOAD (p2 + YR);
  3974.         PC += 2;
  3975.         if (pagetest (p2, YR))
  3976.           /* Over page */
  3977.           clkcount = 6;
  3978.         else
  3979.           /* Same page */
  3980.           clkcount = 5;
  3981.  
  3982.         src = AC - src;
  3983.         SET_CARRY (src < 0x100);
  3984.         SET_SIGN (src);
  3985.         SET_ZERO (src &= 0xff);
  3986.           }
  3987.  
  3988.           break;
  3989.  
  3990.         case 210:
  3991.           {
  3992.         PC++;
  3993.         /* No such opcode. */
  3994.         (void) printf ("Illegal instruction.\n");
  3995.         verflg = 1;
  3996.         --PC;
  3997.  
  3998.         mon (PC);
  3999.           }
  4000.  
  4001.           break;
  4002.  
  4003.         case 211:
  4004.           {
  4005.         register p1 = LOAD (PC + 1);
  4006.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  4007.         PC += 2;
  4008.  
  4009.         /* cmp(--src & 0xff));  */
  4010.  
  4011.         src = (src - 1) & 0xff;        /* DEC+CMP */
  4012.         SET_CARRY (AC >= src);
  4013.         SET_SIGN (AC - src);
  4014.         SET_ZERO (AC != src);
  4015.  
  4016.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  4017.         clkcount = 8;
  4018.           }
  4019.  
  4020.           break;
  4021.  
  4022.         case 212:
  4023.           {
  4024.         PC += 2;
  4025.  
  4026.         clkcount = 4;
  4027.           }
  4028.  
  4029.           break;
  4030.  
  4031.         case 213:
  4032.           {
  4033.         register p1 = LOAD (PC + 1);
  4034.         register unsigned src = LOAD_ZERO (p1 + XR);
  4035.         PC += 2;
  4036.  
  4037.         src = AC - src;
  4038.         SET_CARRY (src < 0x100);
  4039.         SET_SIGN (src);
  4040.         SET_ZERO (src &= 0xff);
  4041.         clkcount = 4;
  4042.           }
  4043.  
  4044.           break;
  4045.  
  4046.         case 214:
  4047.           {
  4048.         register p1 = LOAD (PC + 1);
  4049.         register unsigned src = LOAD_ZERO (p1 + XR);
  4050.         PC += 2;
  4051.  
  4052.         src = (src - 1) & 0xff;
  4053.         SET_SIGN (src);
  4054.         SET_ZERO (src);
  4055.  
  4056.         STORE_ZERO (p1 + XR, (src));;
  4057.         clkcount = 6;
  4058.           }
  4059.  
  4060.           break;
  4061.  
  4062.         case 215:
  4063.           {
  4064.         register p1 = LOAD (PC + 1);
  4065.         register unsigned src = LOAD_ZERO (p1 + XR);
  4066.         PC += 2;
  4067.  
  4068.         /* cmp(--src & 0xff));  */
  4069.  
  4070.         src = (src - 1) & 0xff;        /* DEC+CMP */
  4071.         SET_CARRY (AC >= src);
  4072.         SET_SIGN (AC - src);
  4073.         SET_ZERO (AC != src);
  4074.  
  4075.         STORE_ZERO (p1 + XR, (src));;
  4076.         clkcount = 6;
  4077.           }
  4078.  
  4079.           break;
  4080.  
  4081.         case 216:
  4082.           {
  4083.         PC++;
  4084.  
  4085.  
  4086.         SET_DECIMAL ((0));;
  4087.         clkcount = 2;
  4088.           }
  4089.  
  4090.           break;
  4091.  
  4092.         case 217:
  4093. /*   CMP,    ABSOLUTE_Y */
  4094.           {
  4095.         register p2 = load_abs_addr ();
  4096.         register unsigned src = LOAD (p2 + YR);
  4097.         PC += 3;
  4098.         if (pagetest (p2, YR))
  4099.           /* Over page */
  4100.           clkcount = 5;
  4101.         else
  4102.           /* Same page */
  4103.           clkcount = 4;
  4104.  
  4105.         src = AC - src;
  4106.         SET_CARRY (src < 0x100);
  4107.         SET_SIGN (src);
  4108.         SET_ZERO (src &= 0xff);
  4109.           }
  4110.  
  4111.           break;
  4112.  
  4113.         case 218:
  4114.           {
  4115.         PC++;
  4116.  
  4117.         clkcount = 2;
  4118.           }
  4119.  
  4120.           break;
  4121.  
  4122.         case 219:
  4123.           {
  4124.         register p2 = load_abs_addr ();
  4125.         register unsigned src = LOAD (p2 + YR);
  4126.         PC += 3;
  4127.  
  4128.         /* cmp(--src & 0xff));  */
  4129.  
  4130.         src = (src - 1) & 0xff;        /* DEC+CMP */
  4131.         SET_CARRY (AC >= src);
  4132.         SET_SIGN (AC - src);
  4133.         SET_ZERO (AC != src);
  4134.  
  4135.         STORE (p2 + YR, (src));;
  4136.         clkcount = 7;
  4137.           }
  4138.  
  4139.           break;
  4140.  
  4141.         case 220:
  4142.           {
  4143.         PC += 3;
  4144.  
  4145.         clkcount = 4;
  4146.           }
  4147.  
  4148.           break;
  4149.  
  4150.         case 221:
  4151. /*   CMP,    ABSOLUTE_X */
  4152.           {
  4153.         register p2 = load_abs_addr ();
  4154.         register unsigned src = LOAD (p2 + XR);
  4155.         PC += 3;
  4156.         if (pagetest (p2, XR))
  4157.           /* Over page */
  4158.           clkcount = 5;
  4159.         else
  4160.           /* Same page */
  4161.           clkcount = 4;
  4162.  
  4163.         src = AC - src;
  4164.         SET_CARRY (src < 0x100);
  4165.         SET_SIGN (src);
  4166.         SET_ZERO (src &= 0xff);
  4167.           }
  4168.  
  4169.           break;
  4170.  
  4171.         case 222:
  4172.           {
  4173.         register p2 = load_abs_addr ();
  4174.         register unsigned src = LOAD (p2 + XR);
  4175.         PC += 3;
  4176.  
  4177.         src = (src - 1) & 0xff;
  4178.         SET_SIGN (src);
  4179.         SET_ZERO (src);
  4180.  
  4181.         STORE (p2 + XR, (src));;
  4182.         clkcount = 7;
  4183.           }
  4184.  
  4185.           break;
  4186.  
  4187.         case 223:
  4188.           {
  4189.         register p2 = load_abs_addr ();
  4190.         register unsigned src = LOAD (p2 + XR);
  4191.         PC += 3;
  4192.  
  4193.         /* cmp(--src & 0xff));  */
  4194.  
  4195.         src = (src - 1) & 0xff;        /* DEC+CMP */
  4196.         SET_CARRY (AC >= src);
  4197.         SET_SIGN (AC - src);
  4198.         SET_ZERO (AC != src);
  4199.  
  4200.         STORE (p2 + XR, (src));;
  4201.         clkcount = 7;
  4202.           }
  4203.  
  4204.           break;
  4205.  
  4206.         case 224:
  4207.           {
  4208.         register p1 = LOAD (PC + 1);
  4209.         register unsigned src = p1;
  4210.         PC += 2;
  4211.  
  4212.         src = XR - src;
  4213.         SET_CARRY (src < 0x100);
  4214.         SET_SIGN (src);
  4215.         SET_ZERO (src &= 0xff);
  4216.         clkcount = 2;
  4217.           }
  4218.  
  4219.           break;
  4220.  
  4221.         case 225:
  4222.           {
  4223.         register p1 = LOAD (PC + 1);
  4224.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  4225.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4226.         PC += 2;
  4227.  
  4228.         /*
  4229.          * SBC is not exact either. It has 6% different results too.
  4230.          */
  4231.  
  4232.  
  4233.         SET_SIGN (temp);
  4234.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4235.  
  4236.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4237.  
  4238.         if (IF_DECIMAL ())
  4239.           {
  4240.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4241.               temp -= 6;
  4242.             if (temp > 0x99)
  4243.               temp -= 0x60;
  4244.           }
  4245.         SET_CARRY (temp < 0x100);
  4246.  
  4247.         AC = (temp & 0xff);;
  4248.         clkcount = 6;
  4249.           }
  4250.  
  4251.           break;
  4252.  
  4253.         case 226:
  4254.           {
  4255.         PC += 2;
  4256.  
  4257.         clkcount = 2;
  4258.           }
  4259.  
  4260.           break;
  4261.  
  4262.         case 227:
  4263.           {
  4264.         register p1 = LOAD (PC + 1);
  4265.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  4266.         register unsigned int temp;
  4267.         PC += 2;
  4268.  
  4269.  
  4270.         /* src = ++src & 0xff; AC = sbc(src); */
  4271.  
  4272.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4273.  
  4274.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4275.  
  4276.         SET_SIGN (temp);
  4277.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4278.  
  4279.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4280.  
  4281.         if (IF_DECIMAL ())
  4282.           {
  4283.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4284.               temp -= 6;
  4285.             if (temp > 0x99)
  4286.               temp -= 0x60;
  4287.           }
  4288.         SET_CARRY (temp < 0x100);
  4289.  
  4290.         AC = temp;
  4291.         /* src saved */
  4292.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  4293.         clkcount = 8;
  4294.           }
  4295.  
  4296.           break;
  4297.  
  4298.         case 228:
  4299.           {
  4300.         register p1 = LOAD (PC + 1);
  4301.         register unsigned src = LOAD_ZERO (p1);
  4302.         PC += 2;
  4303.  
  4304.         src = XR - src;
  4305.         SET_CARRY (src < 0x100);
  4306.         SET_SIGN (src);
  4307.         SET_ZERO (src &= 0xff);
  4308.         clkcount = 3;
  4309.           }
  4310.  
  4311.           break;
  4312.  
  4313.         case 229:
  4314.           {
  4315.         register p1 = LOAD (PC + 1);
  4316.         register unsigned src = LOAD_ZERO (p1);
  4317.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4318.         PC += 2;
  4319.  
  4320.         /*
  4321.          * SBC is not exact either. It has 6% different results too.
  4322.          */
  4323.  
  4324.  
  4325.         SET_SIGN (temp);
  4326.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4327.  
  4328.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4329.  
  4330.         if (IF_DECIMAL ())
  4331.           {
  4332.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4333.               temp -= 6;
  4334.             if (temp > 0x99)
  4335.               temp -= 0x60;
  4336.           }
  4337.         SET_CARRY (temp < 0x100);
  4338.  
  4339.         AC = (temp & 0xff);;
  4340.         clkcount = 3;
  4341.           }
  4342.  
  4343.           break;
  4344.  
  4345.         case 230:
  4346.           {
  4347.         register p1 = LOAD (PC + 1);
  4348.         register unsigned src = LOAD_ZERO (p1);
  4349.         PC += 2;
  4350.  
  4351.         src = (src + 1) & 0xff;
  4352.         SET_SIGN (src);
  4353.         SET_ZERO (src);
  4354.  
  4355.         STORE_ZERO (p1, (src));;
  4356.         clkcount = 5;
  4357.           }
  4358.  
  4359.           break;
  4360.  
  4361.         case 231:
  4362.           {
  4363.         register p1 = LOAD (PC + 1);
  4364.         register unsigned src = LOAD_ZERO (p1);
  4365.         register unsigned int temp;
  4366.         PC += 2;
  4367.  
  4368.  
  4369.         /* src = ++src & 0xff; AC = sbc(src); */
  4370.  
  4371.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4372.  
  4373.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4374.  
  4375.         SET_SIGN (temp);
  4376.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4377.  
  4378.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4379.  
  4380.         if (IF_DECIMAL ())
  4381.           {
  4382.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4383.               temp -= 6;
  4384.             if (temp > 0x99)
  4385.               temp -= 0x60;
  4386.           }
  4387.         SET_CARRY (temp < 0x100);
  4388.  
  4389.         AC = temp;
  4390.         /* src saved */
  4391.         STORE_ZERO (p1, (src));;
  4392.         clkcount = 5;
  4393.           }
  4394.  
  4395.           break;
  4396.  
  4397.         case 232:
  4398.           {
  4399.         register unsigned src = XR;
  4400.         PC++;
  4401.  
  4402.         src = (src + 1) & 0xff;
  4403.         SET_SIGN (src);
  4404.         SET_ZERO (src);
  4405.  
  4406.         XR = (src);;
  4407.         clkcount = 2;
  4408.           }
  4409.  
  4410.           break;
  4411.  
  4412.         case 233:
  4413. /*  SBC,    IMMEDIATE */
  4414.           {
  4415.         register p1 = LOAD (PC + 1);
  4416.         register unsigned src = p1;
  4417.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4418.         PC += 2;
  4419.  
  4420.         /*
  4421.          * SBC is not exact either. It has 6% different results too.
  4422.          */
  4423.  
  4424.         if (!IF_DECIMAL ())
  4425.           {
  4426.             SET_SIGN (temp);
  4427.             SET_ZERO (temp & 0xff);    /* Sign and Zero are invalid in decimal mode */
  4428.  
  4429.             SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4430.             SET_CARRY (temp < 0x100);
  4431.             AC = (temp & 0xff);
  4432.  
  4433.           }
  4434.         else
  4435.           {
  4436.             int bcd1, bcd2;
  4437.             BYTE old_A;
  4438.             int C = IF_CARRY ()? 1 : 0;
  4439.  
  4440.             old_A = AC;
  4441.  
  4442.             bcd1 = fromBCD (AC);
  4443.             bcd2 = fromBCD (src);
  4444.  
  4445.             bcd1 = bcd1 - bcd2 - !C;
  4446.  
  4447.             if (bcd1 < 0)
  4448.               bcd1 = 100 - (-bcd1);
  4449.             AC = toBCD (bcd1);
  4450.  
  4451.             SET_CARRY ((old_A < (src + !C)) ? 0 : 1);
  4452.             SET_OVERFLOW ((old_A ^ AC) & 0x80);
  4453.           }
  4454.         clkcount = 2;
  4455.           }
  4456.  
  4457.           break;
  4458.  
  4459.         case 234:
  4460.           {
  4461.         PC++;
  4462.  
  4463.         clkcount = 2;
  4464.           }
  4465.  
  4466.           break;
  4467.  
  4468.         case 235:
  4469.           {
  4470.         register p1 = LOAD (PC + 1);
  4471.         register unsigned src = p1;
  4472.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4473.         PC += 2;
  4474.  
  4475.         /*
  4476.          * SBC is not exact either. It has 6% different results too.
  4477.          */
  4478.  
  4479.  
  4480.         SET_SIGN (temp);
  4481.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4482.  
  4483.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4484.  
  4485.         if (IF_DECIMAL ())
  4486.           {
  4487.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4488.               temp -= 6;
  4489.             if (temp > 0x99)
  4490.               temp -= 0x60;
  4491.           }
  4492.         SET_CARRY (temp < 0x100);
  4493.  
  4494.         AC = (temp & 0xff);;
  4495.         clkcount = 2;
  4496.           }
  4497.  
  4498.           break;
  4499.  
  4500.         case 236:
  4501.           {
  4502.         register p2 = load_abs_addr ();
  4503.         register unsigned src = LOAD (p2);
  4504.         PC += 3;
  4505.  
  4506.         src = XR - src;
  4507.         SET_CARRY (src < 0x100);
  4508.         SET_SIGN (src);
  4509.         SET_ZERO (src &= 0xff);
  4510.         clkcount = 4;
  4511.           }
  4512.  
  4513.           break;
  4514.  
  4515.         case 237:
  4516.           {
  4517.         register p2 = load_abs_addr ();
  4518.         register unsigned src = LOAD (p2);
  4519.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4520.         PC += 3;
  4521.  
  4522.         /*
  4523.          * SBC is not exact either. It has 6% different results too.
  4524.          */
  4525.  
  4526.  
  4527.         SET_SIGN (temp);
  4528.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4529.  
  4530.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4531.  
  4532.         if (IF_DECIMAL ())
  4533.           {
  4534.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4535.               temp -= 6;
  4536.             if (temp > 0x99)
  4537.               temp -= 0x60;
  4538.           }
  4539.         SET_CARRY (temp < 0x100);
  4540.  
  4541.         AC = (temp & 0xff);;
  4542.         clkcount = 4;
  4543.           }
  4544.  
  4545.           break;
  4546.  
  4547.         case 238:
  4548.           {
  4549.         register p2 = load_abs_addr ();
  4550.         register unsigned src = LOAD (p2);
  4551.         PC += 3;
  4552.  
  4553.         src = (src + 1) & 0xff;
  4554.         SET_SIGN (src);
  4555.         SET_ZERO (src);
  4556.  
  4557.         STORE (p2, (src));;
  4558.         clkcount = 6;
  4559.           }
  4560.  
  4561.           break;
  4562.  
  4563.         case 239:
  4564.           {
  4565.         register p2 = load_abs_addr ();
  4566.         register unsigned src = LOAD (p2);
  4567.         register unsigned int temp;
  4568.         PC += 3;
  4569.  
  4570.  
  4571.         /* src = ++src & 0xff; AC = sbc(src); */
  4572.  
  4573.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4574.  
  4575.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4576.  
  4577.         SET_SIGN (temp);
  4578.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4579.  
  4580.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4581.  
  4582.         if (IF_DECIMAL ())
  4583.           {
  4584.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4585.               temp -= 6;
  4586.             if (temp > 0x99)
  4587.               temp -= 0x60;
  4588.           }
  4589.         SET_CARRY (temp < 0x100);
  4590.  
  4591.         AC = temp;
  4592.         /* src saved */
  4593.         STORE (p2, (src));;
  4594.         clkcount = 6;
  4595.           }
  4596.  
  4597.           break;
  4598.  
  4599.         case 240:
  4600. /*   BEQ,    RELATIVE */
  4601.           {
  4602.         register p1 = LOAD (PC + 1);
  4603.         register unsigned src = p1;
  4604.         register BYTE hb;
  4605.         PC += 2;
  4606.         /* Branch if  zero flag is set. */
  4607.         if (IF_ZERO ())
  4608.           {
  4609.             hb = UPPER (PC);
  4610.             PC = REL_ADDR (PC, src);
  4611.             if (brtest (hb))
  4612.               /* Same page */
  4613.               clkcount = 3;
  4614.             else
  4615.               /* Different page */
  4616.               clkcount = 4;
  4617.           }
  4618.         else
  4619.           clkcount = 2;
  4620.           }
  4621.  
  4622.           break;
  4623.  
  4624.         case 241:
  4625.           {
  4626.         register p1 = LOAD (PC + 1);
  4627.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  4628.         register unsigned src = LOAD (p2 + YR);
  4629.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4630.         PC += 2;
  4631.  
  4632.         if (pagetest (p2, YR))
  4633.           /* Over page */
  4634.           clkcount = 6;
  4635.         else
  4636.           /* Same page */
  4637.           clkcount = 5;
  4638.  
  4639.         /*
  4640.          * SBC is not exact either. It has 6% different results too.
  4641.          */
  4642.  
  4643.  
  4644.         SET_SIGN (temp);
  4645.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4646.  
  4647.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4648.  
  4649.         if (IF_DECIMAL ())
  4650.           {
  4651.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4652.               temp -= 6;
  4653.             if (temp > 0x99)
  4654.               temp -= 0x60;
  4655.           }
  4656.         SET_CARRY (temp < 0x100);
  4657.  
  4658.         AC = (temp & 0xff);
  4659.           }
  4660.  
  4661.           break;
  4662.  
  4663.         case 242:
  4664.           {
  4665.         PC++;
  4666.         /* No such opcode. */
  4667.         (void) printf ("Illegal instruction.\n");
  4668.         verflg = 1;
  4669.         --PC;
  4670.  
  4671.         mon (PC);
  4672.           }
  4673.  
  4674.           break;
  4675.  
  4676.         case 243:
  4677.           {
  4678.         register p1 = LOAD (PC + 1);
  4679.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  4680.         register unsigned int temp;
  4681.         PC += 2;
  4682.  
  4683.  
  4684.         /* src = ++src & 0xff; AC = sbc(src); */
  4685.  
  4686.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4687.  
  4688.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4689.  
  4690.         SET_SIGN (temp);
  4691.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4692.  
  4693.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4694.  
  4695.         if (IF_DECIMAL ())
  4696.           {
  4697.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4698.               temp -= 6;
  4699.             if (temp > 0x99)
  4700.               temp -= 0x60;
  4701.           }
  4702.         SET_CARRY (temp < 0x100);
  4703.  
  4704.         AC = temp;
  4705.         /* src saved */
  4706.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  4707.         clkcount = 8;
  4708.           }
  4709.  
  4710.           break;
  4711.  
  4712.         case 244:
  4713.           {
  4714.         PC += 2;
  4715.  
  4716.         clkcount = 4;
  4717.           }
  4718.  
  4719.           break;
  4720.  
  4721.         case 245:
  4722.           {
  4723.         register p1 = LOAD (PC + 1);
  4724.         register unsigned src = LOAD_ZERO (p1 + XR);
  4725.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4726.         PC += 2;
  4727.  
  4728.         /*
  4729.          * SBC is not exact either. It has 6% different results too.
  4730.          */
  4731.  
  4732.  
  4733.         SET_SIGN (temp);
  4734.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4735.  
  4736.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4737.  
  4738.         if (IF_DECIMAL ())
  4739.           {
  4740.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4741.               temp -= 6;
  4742.             if (temp > 0x99)
  4743.               temp -= 0x60;
  4744.           }
  4745.         SET_CARRY (temp < 0x100);
  4746.  
  4747.         AC = (temp & 0xff);;
  4748.         clkcount = 4;
  4749.           }
  4750.  
  4751.           break;
  4752.  
  4753.         case 246:
  4754.           {
  4755.         register p1 = LOAD (PC + 1);
  4756.         register unsigned src = LOAD_ZERO (p1 + XR);
  4757.         PC += 2;
  4758.  
  4759.         src = (src + 1) & 0xff;
  4760.         SET_SIGN (src);
  4761.         SET_ZERO (src);
  4762.  
  4763.         STORE_ZERO (p1 + XR, (src));;
  4764.         clkcount = 6;
  4765.           }
  4766.  
  4767.           break;
  4768.  
  4769.         case 247:
  4770.           {
  4771.         register p1 = LOAD (PC + 1);
  4772.         register unsigned src = LOAD_ZERO (p1 + XR);
  4773.         register unsigned int temp;
  4774.         PC += 2;
  4775.  
  4776.  
  4777.         /* src = ++src & 0xff; AC = sbc(src); */
  4778.  
  4779.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4780.  
  4781.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4782.  
  4783.         SET_SIGN (temp);
  4784.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4785.  
  4786.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4787.  
  4788.         if (IF_DECIMAL ())
  4789.           {
  4790.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4791.               temp -= 6;
  4792.             if (temp > 0x99)
  4793.               temp -= 0x60;
  4794.           }
  4795.         SET_CARRY (temp < 0x100);
  4796.  
  4797.         AC = temp;
  4798.         /* src saved */
  4799.         STORE_ZERO (p1 + XR, (src));;
  4800.         clkcount = 6;
  4801.           }
  4802.  
  4803.           break;
  4804.  
  4805.         case 248:
  4806. /*  SED,    IMPLIED */
  4807.           {
  4808.         PC++;
  4809.  
  4810.         SET_DECIMAL ((1));;
  4811.         clkcount = 2;
  4812.           }
  4813.  
  4814.           break;
  4815.  
  4816.         case 249:
  4817. /*  SBC,    ABSOLUTE_Y */
  4818.           {
  4819.         register p2 = load_abs_addr ();
  4820.         register unsigned src = LOAD (p2 + YR);
  4821.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4822.         PC += 3;
  4823.  
  4824.         if (pagetest (p2, YR))
  4825.           /* Over page */
  4826.           clkcount = 5;
  4827.         else
  4828.           /* Same page */
  4829.           clkcount = 4;
  4830.  
  4831.         /*
  4832.          * SBC is not exact either. It has 6% different results too.
  4833.          */
  4834.  
  4835.  
  4836.         SET_SIGN (temp);
  4837.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4838.  
  4839.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4840.  
  4841.         if (IF_DECIMAL ())
  4842.           {
  4843.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4844.               temp -= 6;
  4845.             if (temp > 0x99)
  4846.               temp -= 0x60;
  4847.           }
  4848.         SET_CARRY (temp < 0x100);
  4849.  
  4850.         AC = (temp & 0xff);
  4851.           }
  4852.  
  4853.           break;
  4854.  
  4855.         case 250:
  4856.           {
  4857.         PC++;
  4858.  
  4859.         clkcount = 2;
  4860.           }
  4861.  
  4862.           break;
  4863.  
  4864.         case 251:
  4865.           {
  4866.         register p2 = load_abs_addr ();
  4867.         register unsigned src = LOAD (p2 + YR);
  4868.         register unsigned int temp;
  4869.         PC += 3;
  4870.  
  4871.  
  4872.         /* src = ++src & 0xff; AC = sbc(src); */
  4873.  
  4874.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4875.  
  4876.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4877.  
  4878.         SET_SIGN (temp);
  4879.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4880.  
  4881.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4882.  
  4883.         if (IF_DECIMAL ())
  4884.           {
  4885.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4886.               temp -= 6;
  4887.             if (temp > 0x99)
  4888.               temp -= 0x60;
  4889.           }
  4890.         SET_CARRY (temp < 0x100);
  4891.  
  4892.         AC = temp;
  4893.         /* src saved */
  4894.         STORE (p2 + YR, (src));;
  4895.         clkcount = 7;
  4896.           }
  4897.  
  4898.           break;
  4899.  
  4900.         case 252:
  4901.           {
  4902.         PC += 3;
  4903.  
  4904.         clkcount = 4;
  4905.           }
  4906.  
  4907.           break;
  4908.  
  4909.         case 253:
  4910. /*   SBC,    ABSOLUTE_X */
  4911.           {
  4912.         register p2 = load_abs_addr ();
  4913.         register unsigned src = LOAD (p2 + XR);
  4914.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4915.         PC += 3;
  4916.  
  4917.         if (pagetest (p2, XR))
  4918.           /* Over page */
  4919.           clkcount = 5;
  4920.         else
  4921.           /* Same page */
  4922.           clkcount = 4;
  4923.  
  4924.         /*
  4925.          * SBC is not exact either. It has 6% different results too.
  4926.          */
  4927.  
  4928.  
  4929.         SET_SIGN (temp);
  4930.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4931.  
  4932.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4933.  
  4934.         if (IF_DECIMAL ())
  4935.           {
  4936.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4937.               temp -= 6;
  4938.             if (temp > 0x99)
  4939.               temp -= 0x60;
  4940.           }
  4941.         SET_CARRY (temp < 0x100);
  4942.  
  4943.         AC = (temp & 0xff);
  4944.           }
  4945.  
  4946.           break;
  4947.  
  4948.         case 254:
  4949.           {
  4950.         register p2 = load_abs_addr ();
  4951.         register unsigned src = LOAD (p2 + XR);
  4952.         PC += 3;
  4953.  
  4954.         src = (src + 1) & 0xff;
  4955.         SET_SIGN (src);
  4956.         SET_ZERO (src);
  4957.  
  4958.         STORE (p2 + XR, (src));;
  4959.         clkcount = 7;
  4960.           }
  4961.  
  4962.           break;
  4963.  
  4964.         case 255:
  4965.           {
  4966.         register p2 = load_abs_addr ();
  4967.         register unsigned src = LOAD (p2 + XR);
  4968.         register unsigned int temp;
  4969.         PC += 3;
  4970.  
  4971.  
  4972.         /* src = ++src & 0xff; AC = sbc(src); */
  4973.  
  4974.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4975.  
  4976.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4977.  
  4978.         SET_SIGN (temp);
  4979.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4980.  
  4981.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4982.  
  4983.         if (IF_DECIMAL ())
  4984.           {
  4985.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4986.               temp -= 6;
  4987.             if (temp > 0x99)
  4988.               temp -= 0x60;
  4989.           }
  4990.         SET_CARRY (temp < 0x100);
  4991.  
  4992.         AC = temp;
  4993.         /* src saved */
  4994.         STORE (p2 + XR, (src));;
  4995.         clkcount = 7;
  4996.           }
  4997.  
  4998.           break;
  4999.  
  5000.  
  5001.  
  5002.         }            /* switch */
  5003.  
  5004.       clk += clkcount;
  5005. }                /* mainloop */
  5006.