home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / apple.c < prev    next >
C/C++ Source or Header  |  1990-06-28  |  105KB  |  3,181 lines
  1. #include <stdio.h>
  2. #include <term.h>
  3.  
  4. fortran  unsigned short tty$in(),
  5.          t1in();
  6.  
  7. int     troff=0,
  8.         tracepoint,
  9.         trace=0,
  10.         brkpoint=0xFA86,
  11.         antalarg,
  12.         soundcounter=0,
  13.         RTScounter=0,
  14.         code,
  15.         STACKcounter,
  16.         old_address,
  17.         old_radflg,
  18.         keycounter=0;
  19.  
  20. typedef struct
  21. {
  22.   unsigned dummy : 9;
  23.   unsigned bit6  : 1; /* N */
  24.   unsigned bit5  : 1; /* V */
  25.   unsigned bit4  : 1; /* B */
  26.   unsigned bit3  : 1; /* D */
  27.   unsigned bit2  : 1; /* I */
  28.   unsigned bit1  : 1; /* Z */
  29.   unsigned bit0  : 1; /* C */
  30. }
  31. bitreg; /* are define to bit 0 - 6 */
  32.  
  33.  
  34. typedef struct
  35. {
  36.   unsigned int high : 8;
  37.   unsigned int low  : 8;
  38. }
  39. progcounterbyte; /* are define to high and low byre */
  40.  
  41.  
  42. typedef union
  43. {
  44.   unsigned short byte;
  45.   bitreg bit;
  46. }
  47. reg; /* are define to variable for bitreg */
  48.  
  49. typedef union
  50. {
  51.   unsigned short byte;
  52.   progcounterbyte hilo;
  53. }
  54. PCbyte; /* are define to variable for progcounterbyte */
  55.  
  56. reg     status_register;   /*   'reg status_register;' = Ex. 'int A' */
  57. PCbyte  program_counter;
  58. int     stack_pointer;
  59. int     Accumulator;
  60. int     indexX;
  61. int     indexY;
  62.  
  63. #define P status_register.byte
  64. #define C status_register.bit.bit0
  65. #define Z status_register.bit.bit1
  66. #define I status_register.bit.bit2
  67. #define D status_register.bit.bit3
  68. #define B status_register.bit.bit4
  69. #define V status_register.bit.bit5
  70. #define N status_register.bit.bit6
  71.  
  72. #define PC  program_counter.byte
  73. #define PCH program_counter.hilo.high
  74. #define PCL program_counter.hilo.low
  75.  
  76. #define S stack_pointer
  77.  
  78. #define A Accumulator
  79. #define X indexX
  80. #define Y indexY
  81.  
  82. char MEMORY [65536];
  83.  
  84. char MEMORY$F8  []=
  85. {
  86.   /* F800:                 ORG  $F800  */
  87.   /* F800:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  88.   /* F810:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  89.   /* F820:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  90.   /* F830:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  91.   /* F840:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  92.   /* F850:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  93.   /* F860:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  94.   /* F870:                 RTS         */     0x60,
  95.   /* F871:   SCRN          LSR  A      */     0x4A,
  96.   /* F872:                 PHP         */     0x08,
  97.   /* F873:                 JSR  GBASCALC*/    0x20,0x47,0xF8,
  98.   /* F876:                 LDA  (GBASL),Y*/   0xB1,0x26,
  99.   /* F878:                 PLP         */     0x28,
  100.   /* F879:   SCRN2         BCC  RTMSKZ */     0x90,0x04,
  101.   /* F87B:                 LSR  A      */     0x4A,
  102.   /* F87C:                 LSR  A      */     0x4A,
  103.   /* F87D:                 LSR  A      */     0x4A,
  104.   /* F87E:                 LSR  A      */     0x4A,
  105.   /* F87F:   RTMSKZ        AND  #$0F   */     0x29,0x0F,
  106.   /* F881:                 RTS         */     0x60,
  107.   /* F882:   INSDS1        LDX  PCL    */     0xA6,0x3A,
  108.   /* F884:                 LDY  PCH    */     0xA4,0x3B,
  109.   /* F886:                 JSR  PRYX2  */     0x20,0x96,0xFD,
  110.   /* F889:                 JSR  PRBLNK */     0x20,0x48,0xF9,
  111.   /* F88C:                 LDA  (PCL,X)*/     0xA1,0x3A,
  112.   /* F88E:   INSDS2        TAY         */     0xA8,
  113.   /* F88F:                 LSR  A      */     0x4A,
  114.   /* F890:                 BCC  IEVEN  */     0x90,0x09,
  115.   /* F892:                 ROR  A      */     0x6A,
  116.   /* F893:                 BCS  ERR    */     0xB0,0x10,
  117.   /* F895:                 CMP  #$A2   */     0xC9,0xA2,
  118.   /* F897:                 BEQ  ERR    */     0xF0,0x0C,
  119.   /* F899:                 AND  #$87   */     0x29,0x87,
  120.   /* F89B:   IEVEN         LSR  A      */     0x4A,
  121.   /* F89C:                 TAX         */     0xAA,
  122.   /* F89D:                 LDA  FMT1,X */     0xBD,0x62,0xF9,
  123.   /* F8A0:                 JSR  SCRN2  */     0x20,0x79,0xF8,
  124.   /* F8A3:                 BNE  GETFMT */     0xD0,0x04,
  125.   /* F8A5:   ERR           LDY  #$80   */     0xA0,0x80,
  126.   /* F8A7:                 LDA  #$0    */     0xA9,0x00,
  127.   /* F8A9:   GETFMT        TAX         */     0xAA,
  128.   /* F8AA:                 LDA  FMT2,X */     0xBD,0xA6,0xF9,
  129.   /* F8AD:                 STA  FORMAT */     0x85,0x2E,
  130.   /* F8AF:                 AND  #$03   */     0x29,0x03,
  131.   /*         *                (P=1 BYTE, 1=2 BYTE, 2=3 BYTE)
  132.   /* F8B1:                 STA  LENGTH */     0x85,0x2F,
  133.   /* F8B3:                 TYA         */     0x98,
  134.   /* F8B4:                 AND  #$8F   */     0x29,0x8F,
  135.   /* F8B6:                 TAX         */     0xAA,
  136.   /* F8B7:                 TYA         */     0x98,
  137.   /* F8B8:                 LDX  #$03   */     0xA0,0x03,
  138.   /* F8BA:                 CPX  #$8A   */     0xE0,0x8A,
  139.   /* F8BC:                 BEQ  MNNDX3 */     0xF0,0x0B,
  140.   /* F8BE:   MNNDX1        LSR  A      */     0x4A,
  141.   /* F8BF:                 BCC  MNNDX3 */     0x90,0x08,
  142.   /* F8C1:                 LSR  A      */     0x4A,
  143.   /* F8C2:   MNNDX2        LSR  A      */     0x4A,
  144.   /* F8C3:                 ORA  #$20   */     0x09,0x20,
  145.   /* F8C5:                 DEY         */     0x88,
  146.   /* F8C6:                 BNE  MNNDX2 */     0xD0,0xFA,
  147.   /* F8C8:                 INY         */     0xC8,
  148.   /* F8C9:   MNNDX3        DEY         */     0x88,
  149.   /* F8CA:                 BNE  MNNDX1 */     0xD0,0xF2,
  150.   /* F8CC:                 RTS         */     0x60,
  151.   /* F8CD:                 DFB  -03-   */     0xFF,0xFF,0xFF,
  152.   /* F8D0:   INSTDSP       JSR  INSDS1 */     0x20,0x82,0xF8,
  153.   /* F8D3:                 PHA         */     0x48,
  154.   /* F8D4:   PRNTOP        LDA  (PCL),Y*/     0xB1,0x3A,
  155.   /* F8D6:                 JSR  PRBYTE */     0x20,0xDA,0xFD,
  156.   /* F8D9:                 LDX  #$01   */     0xA2,0x01,
  157.   /* F8DB:   PRNTBL        JSR  PRBL2  */     0x20,0x4A,0xF9,
  158.   /* F8DE:                 CPY  LENGTH */     0xC4,0x2F,
  159.   /* F8E0:                 INY         */     0xC8,
  160.   /* F8E1:                 BCC  PRNTOP */     0x90,0xF1,
  161.   /* F8E3:                 LDX  #$03   */     0xA2,0x03,
  162.   /* F8E5:                 CPY  #$04   */     0xC0,0x04,
  163.   /* F8E7:                 BCC  PRNTBL */     0x90,0xF2,
  164.   /* F8E9:                 PLA         */     0x68,
  165.   /* F8EA:                 TAY         */     0xA8,
  166.   /* F8EB:                 LDA  MNEML,Y*/     0xB9,0xC0,0xF9,
  167.   /* F8EE:                 STA  LMNEM  */     0x85,0x2C,
  168.   /* F8F0:                 LDA  MNEMR,Y*/     0xB9,0x00,0xFA,
  169.   /* F8F3:                 STA  RMNEM  */     0x85,0x2D,
  170.   /* F8F5:   PRMN1         LDA  #$00   */     0xA9,0x00,
  171.   /* F8F7:                 LDY  #$05   */     0xA0,0x05,
  172.   /* F8F9:   PRMN2         ASL  RMNEM  */     0x06,0x2D,
  173.   /* F8FB:                 ROL  LMNEM  */     0x26,0x2C,
  174.   /* F8FD:                 ROL  A      */     0x2A,
  175.   /* F8FE:                 DEY         */     0x88,
  176.   /* F8FF:                 BNE  PRMN2  */     0xD0,0xF8,
  177.   /* F901:                 ADC  #$BF   */     0x69,0xBF,
  178.   /* F903:                 JSR  COUT   */     0x20,0xED,0xFD,
  179.   /* F906:                 DEX         */     0xCA,
  180.   /* F907:                 BNE  PRMN1  */     0xD0,0xEC,
  181.   /* F909:                 JSR  PRBLNK */     0x20,0x48,0xF9,
  182.   /* F90C:                 LDY  LENGTH */     0xA4,0x2F,
  183.   /* F90E:                 LDX  #$06   */     0xA2,0x06,
  184.   /* F910:   PRADR1        CPX  #$03   */     0xE0,0x03,
  185.   /* F912:                 BEQ  PRADR5 */     0xF0,0x1C,
  186.   /* F914:   PRADR2        ASL  FORMAT */     0x06,0x2E,
  187.   /* F916:                 BCC  PRADR3 */     0x90,0x0E,
  188.   /* F918:                 LDA  CHAR1-1,X*/   0xBD,0xB3,0xF9,
  189.   /* F91B:                 JSR  COUT   */     0x20,0xED,0xFD,
  190.   /* F91E:                 LDA  CHAR2-1,X*/   0xBD,0xB9,0xF9,
  191.   /* F921:                 BEQ  PRADR3 */     0xF0,0x03,
  192.   /* F923:                 JSR  COUT   */     0x20,0xED,0xFD,
  193.   /* F926:   PRADR3        DEX         */     0xCA,
  194.   /* F927:                 BNE  PRADR1 */     0xD0,0xE7,
  195.   /* F929:                 RTS         */     0x60,
  196.   /* F92A:   PRADR4        DEY         */     0x88,
  197.   /* F92B:                 BMI  PRADR2 */     0x30,0xE7,
  198.   /* F92D:                 JSR  PRBYTE */     0x20,0xDA,0xFD,
  199.   /* F930:   PRADR5        LDA  FORMAT */     0xA5,0x2E,
  200.   /* F932:                 CMP  #$E8   */     0xC9,0xE8,
  201.   /* F934:                 LDA  (PCL),Y*/     0xB1,0x3A,
  202.   /* F936:                 BCC  PRADR4 */     0x90,0xF2,
  203.   /* F938:   RELADR        JSR  PCADJ3 */     0x20,0x56,0xF9,
  204.   /* F93B:                 TAX         */     0xAA,
  205.   /* F93C:                 INX         */     0xE8,
  206.   /* F93D:                 BNE  PRNTYX */     0xD0,0x01,
  207.   /* F93F:                 INY         */     0xC8,
  208.   /* F940:   PRNTYX        TYA         */     0x98,
  209.   /* F941:   PRNTAX        JSR  PRBYTE */     0x20,0xDA,0xFD,
  210.   /* F944:   PRNTX         TXA         */     0x8A,
  211.   /* F945:                 JMP  PRBYTE */     0x4C,0xDA,0xFD,
  212.   /* F948:   PRBLNK        LDX  #$03   */     0xA2,0x03,
  213.   /* F94A:   PRBL2         LDA  #$A0   */     0xA9,0xA0,
  214.   /* F94C:   PRBL3         JSR  COUT   */     0x20,0xED,0xFD,
  215.   /* F94F:                 DEX         */     0xCA,
  216.   /* F950:                 BNE  PRBL2  */     0xD0,0xF8,
  217.   /* F952:                 RTS         */     0x60,
  218.   /* F953:   PCADJ         SEC         */     0x38,
  219.   /* F954:   PCADJ2        LDA  LENGTH */     0xA5,0x2F,
  220.   /* F956:   PCADJ3        LDY  PCH    */     0xA4,0x3B,
  221.   /* F958:                 TAX         */     0xAA,
  222.   /* F959:                 BPL  PCADJ4 */     0x10,0x01,
  223.   /* F95B:                 DEY         */     0x88,
  224.   /* F95C:   PCADJ4        ADC  PCL    */     0x65,0x3A,
  225.   /* F95E:                 BCC  RTS2   */     0x90,0x01,
  226.   /* F960:                 INY         */     0xC8,
  227.   /* F961:   RTS2          RTS         */     0x60,
  228.   /*         *             FMT1 BYTES:        XXXXXXY0 INSTRS
  229.              *             IF Y=0             THEN LEFT HALF BYTE
  230.              *             IF Y=1             THEN RIGHT HALF BYTE
  231.              *                                     (X=INDEX)
  232.   /* F962:   FMT1
  233.   /* F962:                 DFB         */     0x04,0x20,0x54,0x30,
  234.   /* F966:                 DFB         */     0x0D,0x80,
  235.   /* F968:                 DFB         */     0x04,0x90,
  236.   /* F96A:                 DFB         */     0x03,0x22,0x54,0x33,
  237.   /* F96E:                 DFB         */     0x0D,0x80,
  238.   /* F970:                 DFB         */     0x04,0x90,
  239.   /* F972:                 DFB         */     0x04,0x20,0x54,0x33,
  240.   /* F976:                 DFB         */     0x0D,0x80,
  241.   /* F978:                 DFB         */     0x04,0x90,
  242.   /* F97A:                 DFB         */     0x04,0x20,0x54,0x3B,
  243.   /* F97E:                 DFB         */     0x0D,0x80,
  244.   /* F980:                 DFB         */     0x04,0x90,
  245.   /* F982:                 DFB         */     0x00,0x22,0x44,0x33,
  246.   /* F986:                 DFB         */     0x0D,0xC8,0x44,
  247.   /* F989:                 DFB         */     0x00,0x11,0x22,0x44,0x33,
  248.   /* F98E:                 DFB         */     0x0D,0xC8,0x44,0xA9,
  249.   /* F992:                 DFB         */     0x01,0x22,0x44,0x33,
  250.   /* F996:                 DFB         */     0x0D,0x80,
  251.   /* F998:                 DFB         */     0x04,0x90,
  252.   /* F99A:                 DFB         */     0x01,0x22,0x44,0x33,
  253.   /* F99E:                 DFB         */     0x0D,0x80,
  254.   /* F9A0:                 DFB         */     0x04,0x90,0x26,0x31,0x87,
  255.   /* F9A5:                 DFB  -01-   */     0x9A,
  256.   /*                                          $ZZXXXY01 INSTR'S
  257.   /* F9A6:   FMT2
  258.   /* F9A6:   ERR           DFB  -01-   */     0x00,
  259.   /* F9A7:   IMM           DFB  -01-   */     0x21,
  260.   /* F9A8:   Z-PAGE        DFB  -01-   */     0x81,
  261.   /* F9A9:   ABS           DFB  -01-   */     0x82,
  262.   /* F9AA:   IMPLIED       DFB  -01-   */     0x00,
  263.   /* F9AB:   ACCUMULATOR   DFB  -01-   */     0x00,
  264.   /* F9AC:   (ZPAG,X)      DFB  -01-   */     0x59,
  265.   /* F9AD:   (ZPAG),Y      DFB  -01-   */     0x4D,
  266.   /* F9AE:   ZPAG,X        DFB  -01-   */     0x91,
  267.   /* F9AF:   ABS,X         DFB  -01-   */     0x92,
  268.   /* F9B0:   ABS,Y         DFB  -01-   */     0x86,
  269.   /* F9B1:   (ABS)         DFB  -01-   */     0x4A,
  270.   /* F9B2:   ZPAG,Y        DFB  -01-   */     0x85,
  271.   /* F9B3:   RELATIVE      DFB  -01-   */     0x9D,
  272.   /* F9B4:   ',),#($'      ASC  -06-   */     0xAC,0xA9,0xAC,0xA3,0xA8,0xA4,
  273.   /* F9BA:   'Y',0,'X$$',0 DFB  -06-   */     0xD9,0x00,0xD8,0xA4,0xA4,0x00,
  274.   /*                                          (A) XXXXX000
  275.   /*                                          (B) XXXYY100
  276.   /*                                          (C) 1XXX1010
  277.   /*                                          (D) XXXYYY10
  278.   /*                                          (E) XXXYYY01
  279.   /*                                              (X = INDEX)
  280.   /* F9C0:                 DFB         */     0x1C,0x8A,
  281.   /* F9C2:                 DFB         */     0x1C,0x23,0x5D,0x8B,
  282.   /* F9C6:                 DFB         */     0x1B,0xA1,0x9B,0x8A,
  283.   /* F9CA:                 DFB         */     0x1D,0x23,0x9D,0x8B,
  284.   /* F9CE:                 DFB         */     0x1D,0xA1,0x00,0x29,
  285.   /* F9D2:                 DFB         */     0x19,0xAE,0x69,0xA8,
  286.   /* F9D6:                 DFB         */     0x19,0x23,0x24,0x53,
  287.   /* F9DA:                 DFB         */     0x1B,
  288.   /* F9DB:                 DFB         */     0x23,0x24,0x53,
  289.   /* F9DE:                 DFB         */     0x19,0xA1,      /* (A) FORMAT
  290.   /* F9E0:                 DFB         */     0x00,0x1A,0x5B, /*       ABOVE
  291.   /* F9E3:                 DFB         */     0x5B,0xA5,0x69,
  292.   /* F9E6:                 DFB         */     0x24,0x24,      /* (B) FORMAT
  293.   /* F9E8:                 DFB         */     0xAE,0xAE,0xA8,
  294.   /* F9EB:                 DFB         */     0xAD,0x29,0x00,
  295.   /* F9EE:                 DFB         */     0x7C,0x00,      /* (C) FORMAT
  296.   /* F9F0:                 DFB         */     0x15,0x9C,0x6D,
  297.   /* F9F3:                 DFB         */     0x9C,0xA5,0x69,
  298.   /* F9F6:                 DFB         */     0x29,0x53,      /* (D) FORMAT
  299.   /* F9F8:                 DFB         */     0x84,0x13,0x34,
  300.   /* F9FB:                 DFB         */     0x11,0xA5,0x69,
  301.   /* F9FE:                 DFB         */     0x23,0xA0,      /* (E) FORMAT
  302.   /* FA00:   MNEMR         DFB         */     0xD8,0x62,0x5A,
  303.   /* FA03:                 DFB         */     0x48,0x26,0x62,
  304.   /* FA06:                 DFB         */     0x94,0x88,0x54,
  305.   /* FA09:                 DFB         */     0x44,0xC8,0x54,
  306.   /* FA0C:                 DFB         */     0x68,0x44,0xE8,
  307.   /* FA0F:                 DFB         */     0x94,0x00,0xB4,
  308.   /* FA12:                 DFB         */     0x08,0x84,0x74,
  309.   /* FA15:                 DFB         */     0xB4,0x28,0x6E,
  310.   /* FA18:                 DFB         */     0x74,0xF4,0xCC,
  311.   /* FA1B:                 DFB         */     0x4A,0x72,0xF2,
  312.   /* FA1E:                 DFB         */     0xA4,0x8A,      /* (A) FORMAT
  313.   /* FA20:                 DFB         */     0x00,0xAA,0xA2,
  314.   /* FA23:                 DFB         */     0xA2,0x74,0x74,
  315.   /* FA26:                 DFB         */     0x74,0x72,      /* (B) FORMAT
  316.   /* FA28:                 DFB         */     0x44,0x68,0xB2,
  317.   /* FA2B:                 DFB         */     0x32,0xB2,0x00,
  318.   /* FA2E:                 DFB         */     0x22,0x00,      /* (C) FORMAT
  319.   /* FA30:                 DFB         */     0x1A,0x1A,0x26,
  320.   /* FA33:                 DFB         */     0x26,0x72,0x72,
  321.   /* FA36:                 DFB         */     0x88,0xC8,      /* (D) FORMAT
  322.   /* FA38:                 DFB         */     0xC4,0xCA,0x26,
  323.   /* FA3B:                 DFB         */     0x48,0x44,0x44,
  324.   /* FA3E:                 DFB         */     0xA2,0xC8,      /* (E) FORMAT
  325.   /* FA40:                 DFB         */     0xFF,0xFF,0xFF,
  326.   /* FA43:                 DFB         */     0,0,0,0,0,0,0,0,0,0,0,0,0,
  327.   /* FA50:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  328.   /* FA60:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  329.   /* FA70:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  330.   /* FA80:                 DFB         */     0,0,0,0,0,0,
  331.   /* FA86:   IRQ           STA  ACC    */     0x85,0x45,
  332.   /* FA88:                 PLA         */     0x68,
  333.   /* FA89:                 PHA         */     0x48,
  334.   /* FA8A:                 ASL  A      */     0x0A,
  335.   /* FA8B:                 ASL  A      */     0x0A,
  336.   /* FA8C:                 ASL  A      */     0x0A,
  337.   /* FA8D:                 BMI  BREAK  */     0x30,0x03,
  338.   /* FA8F:                 JMP  (IRQLOC)*/    0x6C,0xFE,0x03,
  339.   /* FA92:   BREAK         PLP         */     0x28,
  340.   /* FA93:                 JSR  SAV1   */     0x20,0x4C,0xFF,
  341.   /* FA96:                 PLA         */     0x68,
  342.   /* FA97:                 STA  PCL    */     0x85,0x3A,
  343.   /* FA99:                 PLA         */     0x68,
  344.   /* FA9A:                 STA  PCH    */     0x85,0x3B,
  345.   /* FA9C:   XBRK          JSR  INSDS1 */     0x20,0x82,0xF8,
  346.   /* FA9F:                 JSR  RGDSP1 */     0x20,0xDA,0xFA,
  347.   /* FAA2:                 JMP  MON    */     0x4C,0x65,0xFF,
  348.   /* FAA5:                 DFB         */     0,0,0,0,0,0,0,0,0,0,0,
  349.   /* FAB0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  350.   /* FAC0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  351.   /* FAD0:                 DFB         */     0,0,0,0,0,0,0,
  352.   /* FAD7:   REGDSP        JSR  CROUT  */     0x20,0x8E,0xFD,
  353.   /* FADA:   RGDSP1        LDA  #ACC   */     0xA9,0x45,
  354.   /* FADC:                 STA  A3L    */     0x85,0x40,
  355.   /* FADE:                 LDA  #ACC/256*/    0xA9,0x00,
  356.   /* FAE0:                 STA  A3H    */     0x85,0x41,
  357.   /* FAE2:                 LDX  #$FB   */     0xA2,0xFB,
  358.   /* FAE4:   RDSP1         LDA  #$A0   */     0xA9,0xA0,
  359.   /* FAE6:                 JSR  COUT   */     0x20,0xED,0xFD,
  360.   /* FAE9:                 LDA  RTBL-$FB,X*/  0xBD,0x1E,0xFA,
  361.   /* FAEC:                 JSR  COUT   */     0x20,0xED,0xFD,
  362.   /* FAEF:                 LDA  #$BD   */     0xA9,0xBD,
  363.   /* FAF1:                 JSR  COUT   */     0x20,0xED,0xFD,
  364.   /* FAF4:                 LDA  ACC+5,X*/     0xB5,0x4A,
  365.   /* FAF6:                 JSR  PRBYTE */     0x20,0xDA,0xFD,
  366.   /* FAF9:                 INX         */     0xE8,
  367.   /* FAFA:                 BMI  RDSP1  */     0x30,0xE8,
  368.   /* FAFC:                 RTS         */     0x60,
  369.   /* FAFD:   BRANCH        CLC         */     0x18,
  370.   /* FAFE:                 LDY  #$01   */     0xA0,0x01,
  371.   /* FB00:                 LDA  (PCL),Y*/     0xB1,0x3A,
  372.   /* FB02:                 JSR  PCADJ3 */     0x20,0x56,0xF9,
  373.   /* FB05:                 STA  PCL    */     0x85,0x3A,
  374.   /* FB07:                 TYA         */     0x98,
  375.   /* FB08:                 SEC         */     0x38,
  376.   /* FB09:                 BCS  PCINC2 */     0xB0,0xA2,
  377.   /* FB0B:   NBRNCH        JSR  SAVE   */     0x20,0x4A,0xFF,
  378.   /* FB0E:                 SEC         */     0x38,
  379.   /* FB0F:                 BCS  PCINC3 */     0xB0,0x9E,
  380.   /* FB11:   INITBL        NOP         */     0xEA,
  381.   /* FB12:                 NOP         */     0xEA,
  382.   /* FB13:                 JMP  NBRNCH */     0x4C,0x0B,0xFB,
  383.   /* FB16:                 JMP  BRANCH */     0x4C,0xFD,0xFA,
  384.   /* FB19:   RTBL          DFB  'AXYPS'*/     0xC1,0xD8,0xD9,0xD0,0xD3,
  385.   /* FB1E:   PREAD         LDA  PTRIG  */     0xAD,0x70,0xC0,
  386.   /* FB21:                 LDY  #$00   */     0xA0,0x00,
  387.   /* FB23:                 NOP         */     0xEA,
  388.   /* FB24:                 NOP         */     0xEA,
  389.   /* FB25:   PREAD2        LDA  PADDL0,X*/    0xBD,0x64,0xC0,
  390.   /* FB28:                 BPL  RTS2D  */     0x10,0x04,
  391.   /* FB2A:                 INY         */     0xC8,
  392.   /* FB2B:                 BNE  PREAD2 */     0xD0,0xF8,
  393.   /* FB2D:                 DEY         */     0x88,
  394.   /* FB2E:   RTS2D         RTS         */     0x60,
  395.   /* FB2F:   INIT          LDA  #$00   */     0xA9,0x00,
  396.   /* FB31:                 STA  STATUS */     0x85,0x48,
  397.   /* FB33:                 LDA  LORES  */     0xAD,0x56,0xC0,
  398.   /* FB36:                 LDA  LOWSCR */     0xAD,0x54,0xc0,
  399.   /* FB39:   SETTXT        LDA  TXTSET */     0xAD,0x51,0xc0,
  400.   /* FB3C:                 LDA  #$00   */     0xA9,0x00,
  401.   /* FB3E:                 BEQ  SETWND */     0xF0,0x0B,
  402.   /* FB40:   SETGR         LDA  TXTCLR */     0xAD,0x50,0xC0,
  403.   /* FB43:                 LDA  MIXSET */     0xAD,0x53,0xC0,
  404.   /* FB46:                 JSR  CLRTOP */     0x20,0x36,0xF8,
  405.   /* FB49:                 LDA  #$14   */     0xA9,0x14,
  406.   /* FB4B:   SETWND        STA  WNDTOP */     0x85,0x22,
  407.   /* FB4D:                 LDA  #$00   */     0xA9,0x00,
  408.   /* FB4F:                 STA  WNDLFT */     0x85,0x20,
  409.   /* FB51:                 LDA  #$28   */     0xA9,0x28,
  410.   /* FB53:                 STA  WNDWDTH*/     0x85,0x21,
  411.   /* FB55:                 LDA  #$18   */     0xA9,0x18,
  412.   /* FB57:                 STA  WNDBTM */     0x85,0x23,
  413.   /* FB59:                 LDA  #$17   */     0xA9,0x17,
  414.   /* FB5B:   TABV          STA  CV     */     0x85,0x25,
  415.   /* FB5D:                 JMP  VTAB   */     0x4C,0x22,0xFC,
  416.   /* FB60:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  417.   /* FB70:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  418.   /* FB80:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  419.   /* FB90:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  420.   /* FBA0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  421.   /* FBB0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  422.   /* FBC0:                 DFB         */     0,
  423.   /* FBC1:   BASCALC       PHA         */     0x48,
  424.   /* FBC2:                 LSR  A      */     0x4A,
  425.   /* FBC3:                 AND  #$03   */     0x29,0x03,
  426.   /* FBC5:                 ORA  #$04   */     0x09,0x04,
  427.   /* FBC7:                 STA  BASH   */     0x85,0x29,
  428.   /* FBC9:                 PLA         */     0x68,
  429.   /* FBCA:                 AND  #$18   */     0x29,0x18,
  430.   /* FBCC:                 BCC  BSCLC2 */     0x90,0x02,
  431.   /* FBCE:                 ADC  #$7F   */     0x69,0x7F,
  432.   /* FBD0:   BSCLC2        STA  BASL   */     0x85,0x28,
  433.   /* FBD2:                 ASL  A      */     0x0A,
  434.   /* FBD3:                 ASL  A      */     0x0A,
  435.   /* FBD4:                 ORA  BASL   */     0x05,0x28,
  436.   /* FBD6:                 STA  BASL   */     0x85,0x28,
  437.   /* FBD8:                 RTS         */     0x60,
  438.   /* FBD9:   BELL1         CMP  #$87   */     0xC9,0x87,
  439.   /* FBDB:                 BNE  RTS2B  */     0xD0,0x12,
  440.   /* FBDD:                 LDA  #$40   */     0xA9,0x40,
  441.   /* FBDF:                 JSR  WAIT   */     0x20,0xA8,0xFC,
  442.   /* FBE2:                 LDY  #$C0   */     0xA0,0xC0,
  443.   /* FBE4:   BELL2         LDA  #$0C   */     0xA9,0x0C,
  444.   /* FBE6:                 JSR  WAIT   */     0x20,0xA8,0xFC,
  445.   /* FBE9:                 LDA  SPKR   */     0xAD,0x30,0xC0,
  446.   /* FBEC:                 DEY         */     0x88,
  447.   /* FBED:                 BNE  BELL2  */     0xD0,0xF5,
  448.   /* FBEF:   RTS2B         RTS         */     0x60,
  449.   /* FBF0:   STOADV        LDY  CH     */     0xA4,0x24,
  450.   /* FBF2:                 STA  (BASL),Y*/    0x91,0x28,
  451.   /* FBF4:   ADVANCE       INC  CH     */     0xE6,0x24,
  452.   /* FBF6:                 LDA  CH     */     0xA5,0x24,
  453.   /* FBF8:                 CMP  WNDWDTH*/     0xC5,0x21,
  454.   /* FBFA:                 BCS  CR     */     0xB0,0x66,
  455.   /* FBFC:   RTS3          RTS         */     0x60,
  456.   /* FBFD:   VIDOUT        CMP  #$A0   */     0xC9,0xA0,
  457.   /* FBFF:                 BCS  STOADV */     0xB0,0xEF,
  458.   /* FC01:                 TAY         */     0xA8,
  459.   /* FC02:                 BPL  STOADV */     0x10,0xEC,
  460.   /* FC04:                 CMP  #$8D   */     0xC9,0x8D,
  461.   /* FC06:                 BEQ  CR     */     0xF0,0x5A,
  462.   /* FC08:                 CMP  #$8A   */     0xC9,0x8A,
  463.   /* FC0A:                 BEQ  LF     */     0xF0,0x5A,
  464.   /* FC0C:                 CMP  #$88   */     0xC9,0x88,
  465.   /* FC0E:                 BNE  BELL1  */     0xD0,0xC9,
  466.   /* FC10:   BS            DEC  CH     */     0xC6,0x24,
  467.   /* FC12:                 BPL  RTS3   */     0x10,0xE8,
  468.   /* FC14:                 LDA  WNDWDTH*/     0xA5,0x21,
  469.   /* FC16:                 STA  CH     */     0x85,0x24,
  470.   /* FC18:                 DEC  CH     */     0xC6,0x24,
  471.   /* FC1A:   UP            LDA  WNDTOP */     0xA5,0x22,
  472.   /* FC1C:                 CMP  CV     */     0xC5,0x25,
  473.   /* FC1E:                 BCS  RTS4   */     0xB0,0x0B,
  474.   /* FC20:                 DEC  CV     */     0xC6,0x25,
  475.   /* FC22:   VTAB          LDA  CV     */     0xA5,0x25,
  476.   /* FC24:   VTABZ         JSR  BASCALC*/     0x20,0xC1,0xFB,
  477.   /* FC27:                 ADC  WNDLFT */     0x65,0x20,
  478.   /* FC29:                 STA  BASL   */     0x85,0x28,
  479.   /* FC2B:   RTS4          RTS         */     0x60,
  480.   /* FC2C:   ESC1          EOR  #$C0   */     0x49,0xC0,
  481.   /* FC2E:                 BEQ  HOME   */     0xF0,0x28,
  482.   /* FC30:                 ADC  #$FD   */     0x69,0xFD,
  483.   /* FC32:                 BCC  ADVANCE*/     0x90,0xC0,
  484.   /* FC34:                 BEQ  BS     */     0xF0,0xDA,
  485.   /* FC36:                 ADC  #$FD   */     0x69,0xFD,
  486.   /* FC38:                 BCC  LF     */     0x90,0x2C,
  487.   /* FC3A:                 BEQ  UP     */     0xF0,0xDE,
  488.   /* FC3C:                 ADC  #$FD   */     0x69,0xFD,
  489.   /* FC3E:                 BCC  CLREOL */     0x90,0x5C,
  490.   /* FC40:                 BNE  RTS4   */     0xD0,0xE9,
  491.   /* FC42:   CLREOP        LDY  CH     */     0xA4,0x24,
  492.   /* FC44:                 LDA  CV     */     0xA5,0x25,
  493.   /* FC46:   CLEOP1        PHA         */     0x48,
  494.   /* FC47:                 JSR  VTABZ  */     0x20,0x24,0xFC,
  495.   /* FC4A:                 JSR  CLEOLZ */     0x20,0x9E,0xFC,
  496.   /* FC4D:                 LDY  #$00   */     0xA0,0x00,
  497.   /* FC4F:                 PLA         */     0x68,
  498.   /* FC50:                 ADC  #$00   */     0x69,0x00,
  499.   /* FC52:                 CMP  WNDBTM */     0xC5,0x23,
  500.   /* FC54:                 BCC  CLEOP1 */     0x90,0xF0,
  501.   /* FC56:                 BCS  VTAB   */     0xB0,0xCA,
  502.   /* FC58:   HOME          LDA  WNDTOP */     0xA5,0x22,
  503.   /* FC5A:                 STA  CV     */     0x85,0x25,
  504.   /* FC5C:                 LDY  #$00   */     0xA0,0x00,
  505.   /* FC5E:                 STY  CH     */     0x84,0x24,
  506.   /* FC60:                 BEQ  CLEOP1 */     0xF0,0xE4,
  507.   /* FC62:   CR            LDA  #$00   */     0xA9,0x00,
  508.   /* FC64:                 STA  CH     */     0x85,0x24,
  509.   /* FC66:   LF            INC  CV     */     0xE6,0x25,
  510.   /* FC68:                 LDA  CV     */     0xA5,0x25,
  511.   /* FC6A:                 CMP  WNDBTM */     0xC5,0x23,
  512.   /* FC6C:                 BCC  VTABZ  */     0x90,0xB6,
  513.   /* FC6E:                 DEC  CV     */     0xC6,0x25,
  514.   /* FC70:   SCROLL        LDA  WNDTOP */     0xA5,0x22,
  515.   /* FC72:                 PHA         */     0x48,
  516.   /* FC73:                 JSR  VTABZ  */     0x20,0x24,0xFC,
  517.   /* FC76:   SCRL1         LDA  BASL   */     0xA5,0x28,
  518.   /* FC78:                 STA  BAS2L  */     0x85,0x2A,
  519.   /* FC7A:                 LDA  BASH   */     0xA5,0x29,
  520.   /* FC7C:                 STA  BAS2H  */     0x85,0x2B,
  521.   /* FC7E:                 LDY  WNDWDTH*/     0xA4,0x21,
  522.   /* FC80:                 DEY         */     0x88,
  523.   /* FC81:                 PLA         */     0x68,
  524.   /* FC82:                 ADC  #$01   */     0x69,0x01,
  525.   /* FC84:                 CMP  WNDBTM */     0xC5,0x23,
  526.   /* FC86:                 BCS  SCRL3  */     0xB0,0x0D,
  527.   /* FC88:                 PHA         */     0x48,
  528.   /* FC89:                 JSR  VTABZ  */     0x20,0x24,0xFC,
  529.   /* FC8C:   SCRL2         LDA  (BASL),Y*/    0xB1,0x28,
  530.   /* FC81:                 STA  (BAS2L),Y*/   0x91,0x2A,
  531.   /* FC90:                 DEY         */     0x88,
  532.   /* FC91:                 BPL  SCRL2  */     0x10,0xF9,
  533.   /* FC93:                 BMI  SCRL1  */     0x30,0xE1,
  534.   /* FC95:   SCRL3         LDY  #$00   */     0xA0,0x00,
  535.   /* FC97:                 JSR  CLEOLZ */     0x20,0x9E,0xFC,
  536.   /* FC9A:                 BCS  VTAB   */     0xB0,0x86,
  537.   /* FC9C:   CLREOL        LDY  CH     */     0xA4,0x24,
  538.   /* FC9E:   CLEOLZ        LDA  #$A0   */     0xA9,0xA0,
  539.   /* FCA0:   CLEOL2        STA  (BASL),Y*/    0x91,0x28,
  540.   /* FCA2:                 INY         */     0xC8,
  541.   /* FCA3:                 CPY  WNDWDTH*/     0xC4,0x21,
  542.   /* FCA5:                 BCC  CLEOL2 */     0x90,0xF9,
  543.   /* FCA7:                 RTS         */     0x60,
  544.   /* FCA8:   WAIT          SEC         */     0x38,
  545.   /* FCA9:   WAIT2         PHA         */     0x48,
  546.   /* FCAA:   WAIT3         SBC  #$01   */     0xE9,0x01,
  547.   /* FCAC:                 BNE  WAIT3  */     0xD0,0xFC,
  548.   /* FCAE:                 PLA         */     0x68,
  549.   /* FCAF:                 SBC  #$01   */     0xE9,0x01,
  550.   /* FCB1:                 BNE  WAIT2  */     0xD0,0xF6,
  551.   /* FCB3:                 RTS         */     0x60,
  552.   /* FCB4:   NXTA4         INC  A4L    */     0xE6,0x42,
  553.   /* FCB6:                 BNE  NXTA1  */     0xD0,0x02,
  554.   /* FCB8:                 INC  A4H    */     0xE6,0x43,
  555.   /* FCBA:   NXTA1         LDA  A1L    */     0xA5,0x3C,
  556.   /* FCBC:                 CMP  A2L    */     0xC5,0x3E,
  557.   /* FCBE:                 LDA  A1H    */     0xA5,0x3D,
  558.   /* FCC0:                 SBC  A2H    */     0xE5,0x3F,
  559.   /* FCC2:                 INC  A1L    */     0xE6,0x3C,
  560.   /* FCC4:                 BNE  RTS4B  */     0xD0,0x02,
  561.   /* FCC6:                 INC  A1H    */     0xE6,0x3D,
  562.   /* FCC8:   RTS4B         RTS         */     0x60,
  563.   /* FCC9:                 DFB         */     0,0,0,0,0,0,0,
  564.   /* FCD0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  565.   /* FCE0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  566.   /* FCF0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  567.   /* FD00:                 DFB         */     0,0,0,0,0,0,0,0,0,0,0,0,
  568.   /* FD0C:   RDKEY         LDY  CH     */     0xA4,0x24,
  569.   /* FD0E:                 LDA  (BASL),Y*/    0xB1,0x28,
  570.   /* FD10:                 PHA         */     0x48,
  571.   /* FD11:                 AND  #$3F   */     0x29,0x3F,
  572.   /* FD13:                 ORA  #$40   */     0x09,0x40,
  573.   /* FD15:                 STA  (BASL),Y*/    0x91,0x28,
  574.   /* FD17:                 PLA         */     0x68,
  575.   /* FD18:                 JMP  (KSWL) */     0x6C,0x38,0x00,
  576.   /* FD1B:   KEYIN         INC  RNDL   */     0xE6,0x4E,
  577.   /* FD1D:                 BNE  KEYIN2 */     0xD0,0x02,
  578.   /* FD1F:                 INC  RNDH   */     0xE6,0x4F,
  579.   /* FD21:   KEYIN2        BIT  KBD    */     0x2C,0x00,0xC0,
  580.   /* FD24:                 BPL  KEYIN  */     0x10,0xF5,
  581.   /* FD26:                 STA  (BASL),Y*/    0x91,0x28,
  582.   /* FD28:                 LDA  KBD    */     0xAD,0x00,0xC0,
  583.   /* FD2B:                 BIT  KBDSTROB*/    0x2C,0x10,0xC0,
  584.   /* FD2E:                 RTS         */     0x60,
  585.   /* FD2F:   ESC           JSR  RDKEY  */     0x20,0x0C,0xFD,
  586.   /* FD32:                 JSR  ESC1   */     0x20,0x2C,0xFC,
  587.   /* FD35:   RDCHAR        JSR  RDKEY  */     0x20,0x0C,0xFD,
  588.   /* FD38:                 CMP  #$9B   */     0xC9,0x9B,
  589.   /* FD3A:                 BEQ  ESC    */     0xF0,0xF3,
  590.   /* FD3C:                 RTS         */     0x60,
  591.   /* FD3D:   NOTCR         LDA  INVFLG */     0xA5,0x32,
  592.   /* FD3F:                 PHA         */     0x48,
  593.   /* FD40:                 LDA  #$FF   */     0xA9,0xFF,
  594.   /* FD42:                 STA  INVFLG */     0x85,0x32,
  595.   /* FD44:                 LDA  IN,X   */     0xBD,0x00,0x02,
  596.   /* FD74:                 JSR  COUT   */     0x20,0xED,0xFD,
  597.   /* FD4A:                 PLA  PLA    */     0x68,
  598.   /* FD4B:                 STA  INVFLG */     0x85,0x32,
  599.   /* FD4D:                 LDA  IN,X   */     0xBD,0x00,0x02,
  600.   /* FD50:                 CMP  #$88   */     0xC9,0x88,
  601.   /* FD52:                 BEQ  BCKSPC */     0xF0,0x1D,
  602.   /* FD54:                 CMP  #$98   */     0xC9,0x98,
  603.   /* FD56:                 BEQ  CANCEL */     0xF0,0x0A,
  604.   /* FD58:                 CPX  #$F8   */     0xE0,0xF8,
  605.   /* FD5A:                 BCC  NOTCR1 */     0x90,0x03,
  606.   /* FD5C:                 JSR  BELL   */     0x20,0x3A,0xFF,
  607.   /* FD5F:   NOTCR1        INX         */     0xE8,
  608.   /* FD60:                 BNE  NXTCHAR*/     0xD0,0x13,
  609.   /* FD62:   CANCEL        LDA  #$DC   */     0xA9,0xDC,
  610.   /* FD64:                 JSR  COUT   */     0x20,0xED,0xFD,
  611.   /* FD67:   GETLINZ       JSR  CROUT  */     0x20,0x8E,0xFD,
  612.   /* FD6A:   GETLN         LDA  PROMPT */     0xA5,0x33,
  613.   /* FD6C:                 JSR  COUT   */     0x20,0xED,0xFD,
  614.   /* FD6F:                 LDX  #$01   */     0xA2,0x01,
  615.   /* FD71:   BCKSPC        TXA         */     0x8A,
  616.   /* FD72:                 BEQ  GETLNZ */     0xF0,0xF3,
  617.   /* FD74:                 DEX         */     0xCA,
  618.   /* FD75:   NXTCHAR       JSR  RDCHAR */     0x20,0x35,0xFD,
  619.   /* FD78:                 CMP  #PICK  */     0xC9,0x95,
  620.   /* FD7A:                 BNE  CAPTST */     0xD0,0x02,
  621.   /* FD7C:                 LDA  (BASL),Y*/    0xB1,0x28,
  622.   /* FD7E:   CAPTST        CMP  #$E0   */     0xC9,0xE0,
  623.   /* FD80:                 BCC  ADDINP */     0x90,0x02,
  624.   /* FD82:                 AND  #$DF   */     0x29,0xDF,
  625.   /* FD84:   ADDINP        STA  IN,X   */     0x9D,0x00,0x02,
  626.   /* FD87:                 CMP  #$8D   */     0xC9,0x8D,
  627.   /* FD89:                 BNE  NOTCR  */     0xD0,0xB2,
  628.   /* FD8B:                 JSR  CLREOL */     0x20,0x9C,0xFC,
  629.   /* FD8E:   CROUT         LDA  #$8D   */     0xA9,0x8D,
  630.   /* FD90:                 BNE  COUT   */     0xD0,0x5B,
  631.   /* FD92:   PRA1          LDY  A1H    */     0xA4,0x3D,
  632.   /* FD94:                 LDX  A1L    */     0xA6,0x3C,
  633.   /* FD96:   PRYX2         JSR  CROUT  */     0x20,0x8E,0xFD,
  634.   /* FD99:                 JSR  PRNTYA */     0x20,0x40,0xF9,
  635.   /* FD9C:                 JSR  #$00   */     0xA0,0x00,
  636.   /* FD9E:                 LDA  #$AD   */     0xA9,0xAD,
  637.   /* FDA0:                 JMP  COUT   */     0x4C,0xED,0xFD,
  638.   /* FDA3:   XAM8          LDA  A1L    */     0xA5,0x3C,
  639.   /* FDA5:                 ORA  #$07   */     0x09,0x07,
  640.   /* FDA7:                 STA  A2L    */     0x85,0x3E,
  641.   /* FDA9:                 LDA  A1H    */     0xA5,0x3D,
  642.   /* FDAB:                 STA  A2H    */     0x85,0x3F,
  643.   /* FDAD:   MOD8CHK       LDA  A1L    */     0xA5,0x3C,
  644.   /* FDAF:                 AND  #$07   */     0x29,0x07,
  645.   /* FDB1:                 BNE  DATAOUT*/     0xD0,0x03,
  646.   /* FDB3:   XAM           JSR  PRA1   */     0x20,0x92,0xFD,
  647.   /* FDB6:   DATAOUT       LDA  #$A0   */     0xA9,0xA0,
  648.   /* FDB8:                 JSR  COUT   */     0x20,0xED,0xFD,
  649.   /* FDBB:                 LDA  (A1L),Y*/     0xB1,0x3C,
  650.   /* FDBD:                 JSR  PRBYTE */     0x20,0xDA,0xFD,
  651.   /* FDC0:                 JSR  NXTA1  */     0x20,0xBA,0xFC,
  652.   /* FDC3:                 BCC  MOD8CHK*/     0x90,0xE8,
  653.   /* FDC5:   RTS4C         RTS         */     0x60,
  654.   /* FDC6:   XAMPM         LSR  A      */     0x4A,
  655.   /* FDC7:                 BCC  XAM    */     0x90,0xEA,
  656.   /* FDC9:                 LSR  A      */     0x4A,
  657.   /* FDCA:                 LSR  A      */     0x4A,
  658.   /* FDCB:                 LDA  A2L    */     0xA5,0x3E,
  659.   /* FDCD:                 BCC  ADD    */     0x90,0x02,
  660.   /* FDCF:                 EOR  #$FF   */     0x49,0xFF,
  661.   /* FDD1:   ADD           ADC  A1L    */     0x65,0x3C,
  662.   /* FDD3:                 PHA         */     0x48,
  663.   /* FDD4:                 LDA  #$BD   */     0xA9,0xBD,
  664.   /* FDD6:                 JSR  COUT   */     0x20,0xED,0xFD,
  665.   /* FDD9:                 PLA         */     0x68,
  666.   /* FDDA:   PRBYTE        PHA         */     0x48,
  667.   /* FDDB:                 LSR  A      */     0x4A,
  668.   /* FDDC:                 LSR  A      */     0x4A,
  669.   /* FDDD:                 LSR  A      */     0x4A,
  670.   /* FDDE:                 LSR  A      */     0x4A,
  671.   /* FDDF:                 JSR  PRHEXZ */     0x20,0xE5,0xFD,
  672.   /* FDE2:                 PLA         */     0x68,
  673.   /* FDE3:   PRHEX         AND  #$0F   */     0x29,0x0F,
  674.   /* FDE5:   PRHEXZ        ORA  #$B0   */     0x09,0xB0,
  675.   /* FDE7:                 CMP  #$BA   */     0xC9,0xBA,
  676.   /* FDE9:                 BCC  COUT   */     0x90,0x02,
  677.   /* FDEB:                 ADC  #$06   */     0x69,0x06,
  678.   /* FDED:   COUT          JMP  (CSWL) */     0x6C,0x36,0x00,
  679.   /* FDF0:   COUT1         CMP  #$A0   */     0xC9,0xA0,
  680.   /* FDF2:                 BCC  COUTZ  */     0x90,0x02,
  681.   /* FDF4:                 AND  INVFLG */     0x25,0x32,
  682.   /* FDF6:   COUTZ         STY  YSAV1  */     0x84,0x35,
  683.   /* FDF8:                 PHA         */     0x48,
  684.   /* FDF9:                 JSR  VIDOUT */     0x20,0xFD,0xFB,
  685.   /* FDFC:                 PLA         */     0x68,
  686.   /* FDFD:                 LDY  YSAV1  */     0xA4,0x35,
  687.   /* FDFF:                 RTS         */     0x60,
  688.   /* FE00:   BL1           DEC  YSAV   */     0xC6,0x34,
  689.   /* FE02:                 BEQ  XAM8   */     0xF0,0x9F,
  690.   /* FE04:   BLANK         DEX         */     0xCA,
  691.   /* FE05:                 BNE  SETMDZ */     0xD0,0x16,
  692.   /* FE07:                 CMP  #$BA   */     0xC9,0xBA,
  693.   /* FE09:                 BNE  XAMPM  */     0xD0,0xBB,
  694.   /* FE0B:   STOR          STA  MODE   */     0x85,0x31,
  695.   /* FE0D:                 LDA  A2L    */     0xA5,0x3E,
  696.   /* FE0F:                 STA  (A3L),Y*/     0x91,0x40,
  697.   /* FE11:                 INC  A3L    */     0xE6,0x40,
  698.   /* FE13:                 BNE  RTS5   */     0xD0,0x02,
  699.   /* FE15:                 INC  A3H    */     0xE6,0x41,
  700.   /* FE17:   RTS5          RTS         */     0x60,
  701.   /* FE18:   SETMODE       LDY  YSAV   */     0xA4,0x34,
  702.   /* FE1A:                 LDA  IN-1,Y */     0xB9,0xFF,0x01,
  703.   /* FE1D:   SETMDZ        STA  MODE   */     0x85,0x31,
  704.   /* FE1F:                 RTS         */     0x60,
  705.   /* FE20:   LT            LDX  #$01   */     0xA2,0x01,
  706.   /* FE22:   LT2           LDA  A2L,X  */     0xB5,0x3E,
  707.   /* FE24:                 STA  A4L,X  */     0x95,0x42,
  708.   /* FE26:                 STA  A5L,X  */     0x95,0x44,
  709.   /* FE28:                 DEX         */     0xCA,
  710.   /* FE29:                 BPL  LT2    */     0x10,0xF7,
  711.   /* FE2B:                 RTS         */     0x60,
  712.   /* FE2C:   MOVE          LDA  (A1L),Y*/     0xB1,0x3C,
  713.   /* FE2E:                 STA  (A4L),Y*/     0x91,0x42,
  714.   /* FE30:                 JSR  NXTA4  */     0x20,0xB4,0xFC,
  715.   /* FE33:                 BCC  MOVE   */     0x90,0xF7,
  716.   /* FE35:                 RTS         */     0x60,
  717.   /* FE36:                 DFB         */     0,0,0,0,0,0,0,0,0,0,
  718.   /* FE40:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  719.   /* FE50:                 DFB         */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  720.   /* FE5E:   LIST          JSR  A1PC   */     0x20,0x75,0xFE,
  721.   /* FE61:                 LDA  #$14   */     0xA9,0x14,
  722.   /* FE63:   LIST2         PHA         */     0x48,
  723.   /* FE64:                 JSR  INSTDSP*/     0x20,0xD0,0xF8,
  724.   /* FE67:                 JSR  PCADJ  */     0x20,0x53,0xF9,
  725.   /* FE6A:                 STA  PCL    */     0x85,0x3A,
  726.   /* FE6C:                 STY  PCH    */     0x84,0x3B,
  727.   /* FE6E:                 PLA         */     0x68,
  728.   /* FE6F:                 SEC         */     0x38,
  729.   /* FE70:                 SBC  #$01   */     0xE9,0x01,
  730.   /* FE72:                 BNE  LIST2  */     0xD0,0xEF,
  731.   /* FE74:                 RTS         */     0x60,
  732.   /* FE75:   A1PC          TXA         */     0x8A,
  733.   /* FE76:                 BEQ  A1PCRTS*/     0xF0,0x07,
  734.   /* FE78:   A1PCLP        LDA  A1L,X  */     0xB5,0x3C,
  735.   /* FE7A:                 STA  PCL,X  */     0x95,0x3A,
  736.   /* FE7C:                 DEX         */     0xCA,
  737.   /* FE7D:                 BPL  A1PCLP */     0x10,0xF9,
  738.   /* FE7F:   A1PCRTS       RTS         */     0x60,
  739.   /* FE80:   SETINV        LDY  #$3F   */     0xA0,0x3F,
  740.   /* FE82:                 BNE  SETIFLG*/     0xD0,0x02,
  741.   /* FE84:   SETNORM       LDY  #$FF   */     0xA0,0xFF,
  742.   /* FE86:   SETIFLG       STY  INVFLG */     0x84,0x32,
  743.   /* FE88:                 RTS         */     0x60,
  744.   /* FE89:   SETKBD        LDA  #$00   */     0xA9,0x00,
  745.   /* FE8B:   INPORT        STA  A2L    */     0x85,0x3E,
  746.   /* FE8D:   INPRT         LDX  #KSWL  */     0xA2,0x38,
  747.   /* FE8F:                 LDY  #KEYIN */     0xA0,0x1B,
  748.   /* FE91:                 BNE  IOPRT  */     0xD0,0x08,
  749.   /* FE93:   SETVID        LDA  #$00   */     0xA9,0x00,
  750.   /* FE95:   OUTPORT       STA  A2L    */     0x85,0x3E,
  751.   /* FE97:   OUTPRT        LDX  #CSWL  */     0xA2,0x36,
  752.   /* FE99:                 LDY  #COUT1 */     0xA0,0xF0,
  753.   /* FE9B:   IOPRT         LDA  A2L    */     0xA5,0x3E,
  754.   /* FE9D:                 AND  #$0F   */     0x29,0x0F,
  755.   /* FE9F:                 BEQ  IOPRT1 */     0xF0,0x06,
  756.   /* FEA1:                 ORA  #IOADR/256*/  0x09,0xC0,
  757.   /* FEA3:                 LDY  #$00   */     0xA0,0x00,
  758.   /* FEA5:                 BEQ  IOPRT2 */     0xF0,0x02,
  759.   /* FEA7:   IOPRT1        LDA  #COUT1/256*/  0xA9,0xFD,
  760.   /* FEA9:   IOPRT2        STY  LOC0,X */     0x94,0x00,
  761.   /* FEAB:                 STA  LOC1,X */     0x95,0x01,
  762.   /* FEAD:                 RTS         */     0x60,
  763.   /* FEAE:                 NOP         */     0xEA,
  764.   /* FEAF:                 NOP         */     0xEA,
  765.   /* FEB0:                 DFB  -16-   */     0,0,0,0,0,0,
  766.   /* FEB6:   GO            JSR  A1PC   */     0x20,0x75,0xFE,
  767.   /* FEB9:                 JSR  RESTORE*/     0x20,0x3F,0xFF,
  768.   /* FEBC:                 JMP  (PCL)  */     0x6C,0x3A,0x00,
  769.   /* FEBF:   REGZ          JMP  REGDSP */     0x4C,0xD7,0xFA,
  770.   /* FEC2:   TRACE         DEC  YSAV   */     0xC6,0x34,
  771.   /* FEC4:   STEPZ         JSR  A1PC   */     0x20,0x75,0xFE,
  772.   /* FEC7:                 JMP  STEP   */     0x4C,0x43,0xFA,
  773.   /* FECA:   USR           JMP  USRADR */     0x4C,0xF8,0x03,
  774.   /* FECD:                 DFB         */     0,0,0,
  775.   /* FED0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  776.   /* FEE0:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  777.   /* FEF0:                 DFB         */     0,0,0,0,0,0,
  778.   /* FEF6:   CRMON         JSR  BL1    */     0x20,0x00,0xFE,
  779.   /* FEF9:                 PLA         */     0x68,
  780.   /* FEFA:                 PLA         */     0x68,
  781.   /* FEFB:                 BNE  MONZ   */     0xD0,0x6C,
  782.   /* FEFD:                 DFB         */     0,0,0,
  783.   /* FF00:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  784.   /* FF10:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  785.   /* FF20:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,
  786.   /* FF2D:   PRERR         LDA  #$C5   */     0xA9,0xC5,
  787.   /* FF2F:                 JSR  COUT   */     0x20,0xED,0xFD,
  788.   /* FF32:                 LDA  #$D2   */     0xA9,0xD2,
  789.   /* FF34:                 JSR  COUT   */     0x20,0xED,0xFD,
  790.   /* FF37:                 JSR  COUT   */     0x20,0xED,0xFD,
  791.   /* FF3A:   BELL          LDA  #$87   */     0xA9,0x87,
  792.   /* FF3C:                 JMP  COUT   */     0x4C,0xED,0xFD,
  793.   /* FF3F:   RESTORE       LDA  STATUS */     0xA5,0x48,
  794.   /* FF41:                 PHA         */     0x48,
  795.   /* FF42:                 LDA  ACC    */     0xA5,0x45,
  796.   /* FF44:   RESTR1        LDX  XREG   */     0xA6,0x46,
  797.   /* FF46:                 LDY  YREG   */     0xA4,0x47,
  798.   /* FF48:                 PLP         */     0x28,
  799.   /* FF49:                 RTS         */     0x60,
  800.   /* FF4A:   SAVE          STA  ACC    */     0x85,0x45,
  801.   /* FF4C:   SAV1          STX  XREG   */     0x86,0x46,
  802.   /* FF4E:                 STY  YREG   */     0x84,0x47,
  803.   /* FF50:                 PHP         */     0x08,
  804.   /* FF51:                 PLA         */     0x68,
  805.   /* FF52:                 STA  STATUS */     0x85,0x48,
  806.   /* FF54:                 TSX         */     0xBA,
  807.   /* FF55:                 STX  SPNT   */     0x86,0x49,
  808.   /* FF57:                 CLD         */     0xD8,
  809.   /* FF58:                 RTS         */     0x60,
  810.   /* FF59:   RESET         JSR  SETNORM*/     0x20,0x84,0xFE,
  811.   /* FF5C:                 JSR  INIT   */     0x20,0x2F,0xFB,
  812.   /* FF5F:                 JSR  SETVID */     0x20,0x93,0xFE,
  813.   /* FF62:                 JSR  SETKBD */     0x20,0x89,0xFE,
  814.   /* FF65:   MON           CLD         */     0xD8,
  815.   /* FF66:                 JSR  BELL   */     0x20,0x3A,0xFF,
  816.   /* FF69:   MONZ          LDA  #$AA   */     0xA9,0xAA,
  817.   /* FF6B:                 STA  PROMPT */     0x85,0x33,
  818.   /* FF6D:                 JSR  GETLNZ */     0x20,0x67,0xFD,
  819.   /* FF70:                 JSR  ZMODE  */     0x20,0xC7,0xFF,
  820.   /* FF73:   NXTITM        JSR  GETNUM */     0x20,0xA7,0xFF,
  821.   /* FF76:                 STY  YSAV   */     0x84,0x34,
  822.   /* FF78:                 LDY  #$17   */     0xA0,0x17,
  823.   /* FF7A:   CHRSRCH       DEY         */     0x88,
  824.   /* FF7B:                 BMI  MON    */     0x30,0xE8,
  825.   /* FF7D:                 CMP  CHRTBL,Y*/    0xD9,0xCC,0xFF,
  826.   /* FF80:                 BNE  CHRSRCH*/     0xD0,0xF8,
  827.   /* FF82:                 JSR  TOSUB  */     0x20,0xBE,0xFF,
  828.   /* FF85:                 LDY  YSAV   */     0xA4,0x34,
  829.   /* FF87:                 JMP  NXTITM */     0x4C,0x73,0xFF,
  830.   /* FF8A:   DIG           LDX  #$03   */     0xA2,0x03,
  831.   /* FF8C:                 ASL  A      */     0x0A,
  832.   /* FF8D:                 ASL  A      */     0x0A,
  833.   /* FF8E:                 ASL  A      */     0x0A,
  834.   /* FF8F:                 ASL  A      */     0x0A,
  835.   /* FF90:   NXTBIT        ASL  A      */     0x0A,
  836.   /* FF91:                 ROL  A2L    */     0x26,0x3E,
  837.   /* FF93:                 ROL  A2H    */     0x26,0x3F,
  838.   /* FF95:                 DEX         */     0xCA,
  839.   /* FF96:                 BPL  NXTBIT */     0x10,0xF8,
  840.   /* FF98:   NXTBAS        LDA  MODE   */     0xA5,0x31,
  841.   /* FF9A:                 BNE  NXTBS2 */     0xD0,0x06,
  842.   /* FF9C:                 LDA  A2H,X  */     0xB5,0x3F,
  843.   /* FF9E:                 STA  A1H,X  */     0x95,0x3D,
  844.   /* FFA0:                 STA  A3H,X  */     0x95,0x41,
  845.   /* FFA2:   NXTBS2        INX         */     0xE8,
  846.   /* FFA3:                 BEQ  NXTBAS */     0xF0,0xF3,
  847.   /* FFA5:                 BNE  NXTCHR */     0xD0,0x06,
  848.   /* FFA7:   GETNUM        LDX  #$00   */     0xA2,0x00,
  849.   /* FFA9:                 STX  A2L    */     0x86,0x3E,
  850.   /* FFAB:                 STX  A2L    */     0x86,0x3F,
  851.   /* FFAD:   NEXTCHR       LDA  IN,X   */     0xB9,0x00,0x02,
  852.   /* FFB0:                 INY         */     0xC8,
  853.   /* FFB1:                 EOR  #$B0   */     0x49,0xB0,
  854.   /* FFB3:                 CMP  #$0A   */     0xC9,0x0A,
  855.   /* FFB5:                 BCC  DIG    */     0x90,0xD3,
  856.   /* FFB7:                 ADC  #$88   */     0x69,0x88,
  857.   /* FFB9:                 CMP  #$FA   */     0xC9,0xFA,
  858.   /* FFBB:                 BCS  DIG    */     0xB0,0xCD,
  859.   /* FFBD:                 RTS         */     0x60,
  860.   /* FFBE:   TOSUB         LDA  #GO/256*/     0xA9,0xFE,
  861.   /* FFC0:                 PHA         */     0x48,
  862.   /* FFC1:                 LDA  SUBTBL,Y*/    0xB9,0xE3,0xFF,
  863.   /* FFC4:                 PHA         */     0x48,
  864.   /* FFC5:                 LDA  MODE   */     0xA5,0x31,
  865.   /* FFC7:   ZMODE         LDY  #$00   */     0xA0,0x00,
  866.   /* FFC9:                 STY  MODE   */     0x84,0x31,
  867.   /* FFCB:                 RTS         */     0x60,
  868.   /* FFCC:   CHRTBL        DFB  CTRL-C */     0xBC,
  869.   /* FFCD:                 DFB  CTRL-Y */     0xB2,
  870.   /* FFCE:                 DFB  CTRL-E */     0xBE,
  871.   /* FFCF:                 DFB  T      */     0xED,
  872.   /* FFD0:                 DFB  V      */     0xEF,
  873.   /* FFD1:                 DFB  CTRL-K */     0xC4,
  874.   /* FFD2:                 DFB  S      */     0xEC,
  875.   /* FFD3:                 DFB  CTRL-P */     0xA9,
  876.   /* FFD4:                 DFB  CTRL-B */     0xBB,
  877.   /* FFD5:                 DFB  -      */     0xA6,
  878.   /* FFD6:                 DFB  +      */     0xA4,
  879.   /* FFD7:                 DFB  M      */     0x06,
  880.   /* FFD8:                 DFB  <      */     0x95,
  881.   /* FFD9:                 DFB  N      */     0x07,
  882.   /* FFDA:                 DFB  I      */     0x02,
  883.   /* FFDB:                 DFB  L      */     0x05,
  884.   /* FFDC:                 DFB  W      */     0xF0,
  885.   /* FFDD:                 DFB  G      */     0x00,
  886.   /* FFDE:                 DFB  R      */     0xEB,
  887.   /* FFDF:                 DFB  :      */     0x93,
  888.   /* FFE0:                 DFB  .      */     0xA7,
  889.   /* FFE1:                 DFB  'CR'   */     0xC6,
  890.   /* FFE2:                 DFB  'BLANK'*/     0x99,
  891.   /* FFE3:   SUBTBL        DFB  #BASCONT-1*/  0xB2,
  892.   /* FFE4:                 DFB  #USER-1*/     0xC9,
  893.   /* FFE5:                 DFB  #REGZ-1*/     0xBE,
  894.   /* FFE6:                 DFB  #TRACE-1*/    0xC1,
  895.   /* FFE7:                 DFB  #VFY-1 */     0x35,
  896.   /* FFE8:                 DFB  #INPRT-1*/    0x8C,
  897.   /* FFE9:                 DFB  #STEPZ-1*/    0xC3,
  898.   /* FFEA:                 DFB  #OUTPTR*/     0x96,
  899.   /* FFEB:                 DFB  #XBASIC-1*/   0xAF,
  900.   /* FFEC:                 DFB  #SETMODE-1*/  0x17,
  901.   /* FFED:                 DFB  #SETMODE-1*/  0x17,
  902.   /* FFEE:                 DFB  #MOVE-1 */    0x2B,
  903.   /* FFEF:                 DFB  #LT-1   */    0x1F,
  904.   /* FFF0:                 DFB  #SETNORM-1*/  0x83,
  905.   /* FFF1:                 DFB  #SETINV-1*/   0x7F,
  906.   /* FFF2:                 DFB  #LIST-1*/     0x5D,
  907.   /* FFF3:                 DFB  #write-1*/    0xCC,
  908.   /* FFF4:                 DFB  #GO-1  */     0xB5,
  909.   /* FFF5:                 DFB  #READ-1*/     0xFC,
  910.   /* FFF6:                 DFB  #SETMODE-1*/  0x17,
  911.   /* FFF7:                 DFB  #SETMODE-1*/  0x17,
  912.   /* FFF8:                 DFB  #CRMON-1*/    0xF5,
  913.   /* FFF9:                 DFB  #BLANK-1*/    0x03,
  914.   /* FFFA:                 DFB  #NMI   */     0xFB,0x03,
  915.   /* FFFC:                 DFB  #RESET */     0x59,0xFF,
  916.   /* FFFE:                 DFB  #IRQ   */     0x86,0xFA,
  917.   0
  918. };
  919.  
  920. char PROGRAM []=
  921. {
  922.   /* 0300:                 ORG  $0300  */
  923.   /* 0300:   TEST          LDA  #'A'   */     0xA9,0xC1,
  924.   /* 0302:   LOOP          JSR  COUT   */     0x20,0xED,0xFD,
  925.   /* 0305:                 CLC         */     0x18,
  926.   /* 0306:                 ADC  #$01   */     0x69,0x01,
  927.   /* 0308:                 CMP  #'['   */     0xC9,0xDB,
  928.   /* 030A:                 BNE  LOOP   */     0xD0,0xF6,
  929.   /* 030C:                 RTS         */     0x60,
  930.   /* 030D:                 DFB  -16-   */     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  931. };
  932.  
  933. binprn(tkn,len)
  934. unsigned long int tkn,
  935.                   len;
  936. {
  937.   int loop,
  938.       temp;
  939.   static char dword []="00000000000000000000000000000000";
  940.   for (loop=1;loop<(len+1);loop++)
  941.   {
  942.     temp=1<<(loop-1);
  943.     if ((tkn&temp) == temp)
  944.       dword [len-loop] ='1';
  945.     else
  946.       dword [len-loop] ='0';
  947.   }
  948.   dword [len] =0;
  949.   printf("%s",dword);
  950. }
  951.  
  952. hexprn(byte,len)
  953. unsigned long int byte,
  954.                   len;
  955. {
  956.   int loop;
  957.   for (loop=0;loop<len;loop++)
  958.   {
  959.     printf("%c",(((((byte>>((len-1)*4))&15)>9)&1)*7
  960.                  +((byte>>((len-1)*4))&15))+060 | 0x80);
  961.     byte=byte<<4;
  962.   }
  963. }
  964.  
  965. halfdup()
  966. {
  967.   struct term temp;
  968.   gterm(&temp);
  969.   temp.tt_flags=temp.tt_flags & (65535 - (ECHO+CRLF));
  970.   sterm(&temp);
  971. }
  972.  
  973. fulldup()
  974. {
  975.   struct term temp;
  976.   gterm(&temp);
  977.   temp.tt_flags=temp.tt_flags | (ECHO+CRLF);
  978.   sterm(&temp);
  979. }
  980.  
  981. botomline()
  982. {
  983.     printf("\033\067");
  984.     printf("\033\133\062\063;\061f");
  985. }
  986.  
  987. char inkey(key)
  988. char key;
  989. {
  990.   short temp;
  991.   /*  if (tty$in() & 0x8000)  */
  992.   keycounter += 1;
  993.   if (keycounter >= 4)
  994.   {
  995.     keycounter = 0;
  996.     t1in(temp);
  997.     if ((temp & 0x7F) == 0x0A)
  998.       temp = 0x0D;
  999.     return((int) (temp | 0x80));
  1000.   }
  1001.   return (key & 0xFF);
  1002. }
  1003.  
  1004. charprn(charen)
  1005. char charen;
  1006. {
  1007.   if ((charen & 0x80) == 0)
  1008.   {
  1009.     /* inv or flash */
  1010.     if ((charen & 0x40) == 0)
  1011.     {
  1012.       /* invers */
  1013.       char charen2;
  1014.       printf("\033[7m");
  1015.  
  1016.       if ((charen & 0x20) == 0)
  1017.         charen2 = (charen & 0x3F) + 0x40;
  1018.       else
  1019.         charen2 = (charen & 0x3F);
  1020.  
  1021.       printf("%c",charen2);
  1022.       printf("\033[m");
  1023.     }
  1024.     else
  1025.     {
  1026.       /* flash */
  1027.       char charen2;
  1028.       printf("\033[5m");
  1029.       if ((charen & 0x20) == 0)
  1030.         charen2 = (charen & 0x3F) + 0x40;
  1031.       else
  1032.         charen2 = (charen & 0x3F);
  1033.  
  1034.       if (charen2 == 0x20)
  1035.         printf("%c",0x18);
  1036.       else
  1037.         printf("%c",charen2);
  1038.       printf("\033[m");
  1039.     }
  1040.   }
  1041.   else
  1042.   {
  1043.     if (charen < 0xA0)
  1044.     {
  1045.       /* ctrl */
  1046.       printf(".");
  1047.     }
  1048.     else
  1049.     {
  1050.       /* norm */
  1051.       printf("%c",charen & 0x7F);
  1052.     }
  1053.   }
  1054. }
  1055.  
  1056. prnspc(antal)
  1057. int antal;
  1058. {
  1059.   int loop;
  1060.   for(loop=0;loop<antal;loop++)
  1061.     printf(" ");
  1062. }
  1063.  
  1064. int video_check(address)
  1065. int address;
  1066. {
  1067.   int radflg;
  1068.   radflg = 0;
  1069.   radflg = radflg +1 *((address >= 0x0400) && (address <= 0x0477));
  1070.   radflg = radflg +2 *((address >= 0x0480) && (address <= 0x04F7));
  1071.   radflg = radflg +3 *((address >= 0x0500) && (address <= 0x0577));
  1072.   radflg = radflg +4 *((address >= 0x0580) && (address <= 0x05F7));
  1073.   radflg = radflg +5 *((address >= 0x0600) && (address <= 0x0677));
  1074.   radflg = radflg +6 *((address >= 0x0680) && (address <= 0x06F7));
  1075.   radflg = radflg +7 *((address >= 0x0700) && (address <= 0x0777));
  1076.   radflg = radflg +8 *((address >= 0x0780) && (address <= 0x07F7));
  1077.   return(radflg);
  1078. }
  1079.  
  1080. video_out(address,radflg)
  1081. int address,
  1082.     radflg;
  1083. {
  1084.   int has_send = 0,
  1085.       old_x,
  1086.       old_y,
  1087.       old_byte;
  1088.   old_x = (old_address - (0x0400+0x80*(old_radflg-1)))%40;
  1089.   old_y = (((old_address - (0x0400+0x80*(old_radflg-1)))/40)*8)+(old_radflg-1);
  1090.   old_byte = MEMORY [old_address];
  1091.  
  1092.  
  1093.   {
  1094.     int x,
  1095.         y,
  1096.         byte;
  1097.     x = (address - (0x0400+0x80*(radflg-1)))%40;
  1098.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  1099.     byte = MEMORY [address];
  1100.  
  1101.     if ((y == old_y) && (x == old_x+1))
  1102.     {
  1103.       charprn(old_byte);
  1104.       charprn(byte);
  1105.       has_send = 1;
  1106.     }
  1107.  
  1108.     if ((y == old_y) && (x == old_x-1))
  1109.     {
  1110.       printf("\010");
  1111.       charprn(byte);
  1112.       has_send = 1;
  1113.     }
  1114.  
  1115.     if ((x == old_x) && (y == old_y+1))
  1116.     {
  1117.       printf("\033D");
  1118.       charprn(byte);
  1119.       has_send = 1;
  1120.     }
  1121.  
  1122.     if ((x == old_x) && (y == old_y+1))
  1123.     {
  1124.       printf("\033M");
  1125.       charprn(byte);
  1126.       has_send = 1;
  1127.     }
  1128.  
  1129.     if ((x == 0) && (y == old_y+1))
  1130.     {
  1131.       printf("\033E");
  1132.       charprn(byte);
  1133.       has_send = 1;
  1134.     }
  1135.  
  1136.     if (!has_send)
  1137.     {
  1138.       printf("\033[%d;%df",y+1,x+1);
  1139.       charprn(byte);
  1140.     }
  1141.   }
  1142.  
  1143.   printf("\010\033\067");
  1144.   old_address = address;
  1145.   old_radflg = radflg;
  1146. }
  1147.  
  1148.  
  1149. CPU(coden)
  1150. int coden;
  1151. {
  1152.   code =coden;
  1153.   switch(code)
  1154.   {
  1155.     case 0x00 : BRK();                         break;
  1156.     case 0x05 : ORAzpa();                      break;
  1157.     case 0x06 : ASLzpa();                      break;
  1158.     case 0x08 : PHP();                         break;
  1159.     case 0x09 : ORAimm();                      break;
  1160.     case 0x10 : BPLrel();                      break;
  1161.     case 0x0A : ASLacc();                      break;
  1162.     case 0x18 : CLC();                         break;
  1163.     case 0x20 : JSRabs();                      break;
  1164.     case 0x25 : ANDzpa();                      break;
  1165.     case 0x26 : ROLzpa();                      break;
  1166.     case 0x28 : PLP();                         break;
  1167.     case 0x29 : ANDimm();                      break;
  1168.     case 0x2A : ROLacc();                      break;
  1169.     case 0x2C : BITabs();                      break;
  1170.     case 0x30 : BMIrel();                      break;
  1171.     case 0x38 : SEC();                         break;
  1172.     case 0x40 : RTI();                         break;
  1173.     case 0x48 : PHA();                         break;
  1174.     case 0x49 : EORimm();                      break;
  1175.     case 0x4A : LSRacc();                      break;
  1176.     case 0x4C : JMPabs();                      break;
  1177.     case 0x60 : RTS();                         break;
  1178.     case 0x65 : ADCzpa();                      break;
  1179.     case 0x68 : PLA();                         break;
  1180.     case 0x69 : ADCimm();                      break;
  1181.     case 0x6A : RORacc();                      break;
  1182.     case 0x6C : JMPind();                      break;
  1183.     case 0x84 : STYzpa();                      break;
  1184.     case 0x85 : STAzpa();                      break;
  1185.     case 0x86 : STXzpa();                      break;
  1186.     case 0x88 : DEY();                         break;
  1187.     case 0x8A : TXA();                         break;
  1188.     case 0x90 : BCCrel();                      break;
  1189.     case 0x91 : STAind_y();                    break;
  1190.     case 0x94 : STYzpa_x();                    break;
  1191.     case 0x95 : STAzpa_x();                    break;
  1192.     case 0x98 : TYA();                         break;
  1193.     case 0x9D : STAabs_x();                    break;
  1194.     case 0xA0 : LDYimm();                      break;
  1195.     case 0xA1 : LDAind_x();                    break;
  1196.     case 0xA2 : LDXimm();                      break;
  1197.     case 0xA4 : LDYzpa();                      break;
  1198.     case 0xA5 : LDAzpa();                      break;
  1199.     case 0xA6 : LDXzpa();                      break;
  1200.     case 0xA8 : TAY();                         break;
  1201.     case 0xA9 : LDAimm();                      break;
  1202.     case 0xAA : TAX();                         break;
  1203.     case 0xAD : LDAabs();                      break;
  1204.     case 0xB0 : BCSrel();                      break;
  1205.     case 0xB1 : LDAind_y();                    break;
  1206.     case 0xB5 : LDAzpa_x();                    break;
  1207.     case 0xB9 : LDAabs_y();                    break;
  1208.     case 0xBA : TSX();                         break;
  1209.     case 0xBD : LDAabs_x();                    break;
  1210.     case 0xC0 : CPYimm();                      break;
  1211.     case 0xC4 : CPYzpa();                      break;
  1212.     case 0xC5 : CMPzpa();                      break;
  1213.     case 0xC6 : DECzpa();                      break;
  1214.     case 0xC8 : INY();                         break;
  1215.     case 0xC9 : CMPimm();                      break;
  1216.     case 0xCA : DEX();                         break;
  1217.     case 0xD0 : BNErel();                      break;
  1218.     case 0xD8 : CLD();                         break;
  1219.     case 0xD9 : CMPabs_y();                    break;
  1220.     case 0xE0 : CPXimm();                      break;
  1221.     case 0xE6 : INCzpa();                      break;
  1222.     case 0xE8 : INX();                         break;
  1223.     case 0xE9 : SBCimm();                      break;
  1224.     case 0xF0 : BEQrel();                      break;
  1225.  
  1226.     default   : NOT();
  1227.   }
  1228.   if (D == 1);
  1229.     /* Z IS INVALIDE */
  1230.  
  1231.   if ((antalarg > 2) && (trace))
  1232.   {
  1233.     printf("\033\070");
  1234.   }
  1235. }
  1236.  
  1237. NOT()
  1238. {
  1239.   B = 1;
  1240.   I = 0;
  1241. }
  1242.  
  1243. ADCimm()
  1244. {
  1245.   int pc,
  1246.   code,
  1247.   a,
  1248.   c;
  1249.   pc = PC-1;
  1250.   code = loadOp();
  1251.   a = A;
  1252.   c = C;
  1253.   A = (A & 0xFF)+ code + C;
  1254.   C = (A == 0x100);
  1255.   N = ((A & 0xFF)>>7);
  1256.   Z = (A & 0xFF)==0;
  1257.   V = (A - a) > 127;
  1258.   if (trace)
  1259.   {
  1260.     if (antalarg > 2)
  1261.       botomline();
  1262.     hexprn(pc,4);             printf("-69 ");             hexprn(code,2);
  1263.     printf("   :ADC #$");     hexprn(code,2);
  1264.     prnspc(RTScounter);       printf("    ;Adc #");       hexprn(code,2);
  1265.     printf(" to A ");         hexprn((a & 0xFF),2);
  1266.     printf(" with C ");       binprn((c & 1),1);          printf(" ");
  1267.     prnspc(11 - RTScounter);
  1268.     printf("'");              statprn();                  printf("'\n");
  1269.   }
  1270. }
  1271.  
  1272. ADCzpa()
  1273. {
  1274.   int pc,
  1275.       code,
  1276.       a,
  1277.       c;
  1278.   pc = PC-1;
  1279.   code = loadOp();
  1280.   a = (A & 0xFF);
  1281.   c = C;
  1282.   A = (A & 0xFF)+ loadCo(0x00,code) + C;
  1283.   C = (A == 0x100);
  1284.   N = ((A & 0xFF) >> 7);
  1285.   Z =  (A & 0xFF) == 0;
  1286.   V = (A - a) > 127;
  1287.   if (trace)
  1288.   {
  1289.     if (antalarg > 2)
  1290.       botomline();
  1291.     hexprn(pc,4);             printf("-65 ");            hexprn(code,2);
  1292.     printf("   :ADC $");      hexprn(code,2);            printf("     ");
  1293.     prnspc(RTScounter);       printf(";Add $");          hexprn(code,2);
  1294.     printf(" [");             hexprn(loadCo(0x00,code),2);
  1295.     printf("] to A ");        hexprn((a & 0xFF),2);
  1296.     printf(" with C ");       binprn((c & 1),1);         printf(" ");
  1297.     prnspc(6 - RTScounter);
  1298.     printf("'");              statprn();                 printf("'\n");
  1299.   }
  1300. }
  1301.  
  1302. ASLzpa()
  1303. {
  1304.   int pc,
  1305.       code,
  1306.       codel,
  1307.       code2;
  1308.   pc = PC-1;
  1309.   codel = loadOp();
  1310.   code = loadCo(0x00,codel);
  1311.   code2 = (code & 0xFF) << 1;
  1312.   saveCo(0x00,codel,code2);
  1313.   N = (code2 & 0x80) != 0;
  1314.   Z = (code2 & 0xFF) == 0;
  1315.   C = (code2 & 0x100) != 0;
  1316.   if (trace)
  1317.   {
  1318.     if (antalarg > 2)
  1319.       botomline();
  1320.     hexprn(pc,4);             printf("-06 ");              hexprn(codel,2);
  1321.     printf("   :ASL $");      hexprn(codel,2);             printf("     ");
  1322.     prnspc(RTScounter);       printf(";Rotate left ");     hexprn(code,2);
  1323.     printf(" from to C ");    binprn((C & 1),1);
  1324.     prnspc(10 - RTScounter);
  1325.     printf("'");              statprn();                   printf("'\n");
  1326.   }
  1327. }
  1328.  
  1329. ANDimm()
  1330. {
  1331.   int pc,
  1332.       code,
  1333.       a;
  1334.   pc = PC-1;
  1335.   code = loadOp();
  1336.   a = A;
  1337.   A =  (A & 0xFF) & code;
  1338.   N = ((A & 0xFF) >> 7);
  1339.   Z =  (A & 0xFF) == 0;
  1340.   if (trace)
  1341.   {
  1342.     if (antalarg > 2)
  1343.       botomline();
  1344.     hexprn(pc,4);             printf("-29 ");             hexprn(code,2);
  1345.     printf("   :AND #$");     hexprn(code,2);             printf("    ");
  1346.     prnspc(RTScounter);       printf(";And #");           hexprn(code,2);
  1347.     printf(" with A ");       hexprn((a & 0xFF),2);       printf(" ");
  1348.     prnspc(18 - RTScounter);
  1349.     printf("'");              statprn();                  printf("'\n");
  1350.   }
  1351. }
  1352.  
  1353. ANDzpa()
  1354. {
  1355.   int pc,
  1356.       code,
  1357.       codel,
  1358.       a;
  1359.   pc = PC-1;
  1360.   codel = loadOp();
  1361.   a = A;
  1362.   code = loadCo(0x00,codel);
  1363.   A =  (A & 0xFF) & code;
  1364.   N = ((A & 0xFF) >> 7);
  1365.   Z =  (A & 0xFF) == 0;
  1366.   if (trace)
  1367.   {
  1368.     if (antalarg > 2)
  1369.       botomline();
  1370.     hexprn(pc,4);             printf("-25 ");             hexprn(codel,2);
  1371.     printf("   :AND $");      hexprn(codel,2);            printf("     ");
  1372.     prnspc(RTScounter);
  1373.     printf(";And ");          hexprn(code,2);
  1374.     printf(" with A ");       hexprn((a & 0xFF),2);       printf(" ");
  1375.     prnspc(19 - RTScounter);
  1376.     printf("'");              statprn();                  printf("'\n");
  1377.   }
  1378. }
  1379.  
  1380. ASLacc()
  1381. {
  1382.   int pc,
  1383.       a;
  1384.   pc = PC-1;
  1385.   a = A;
  1386.   A = (A & 0xFF) << 1;
  1387.   N = (A & 0x80) != 0;
  1388.   Z = (A & 0xFF) == 0;
  1389.   C = (A & 0x100) != 0;
  1390.   if (trace)
  1391.   {
  1392.     if (antalarg > 2)
  1393.       botomline();
  1394.     hexprn(pc,4);             printf("-0A   ");
  1395.     printf("   :ASL A       ");
  1396.     prnspc(RTScounter);       printf(";Shift left A ");    hexprn((a & 0xFF),2);
  1397.     printf(" one to C ");     binprn((C & 1),1);           printf(" ");
  1398.     prnspc(9 - RTScounter);
  1399.     printf("'");              statprn();                   printf("'\n");
  1400.   }
  1401. }
  1402.  
  1403. BCCrel()
  1404. {
  1405.   int pc,
  1406.   code;
  1407.   pc = PC-1;
  1408.   code = loadOp();
  1409.   code = (code>127)?(code-256):code;
  1410.   if (C == 0)
  1411.     PC+=code;
  1412.   if (trace)
  1413.   {
  1414.     if (antalarg > 2)
  1415.       botomline();
  1416.     hexprn(pc,4);             printf("-90 ");             hexprn(code,2);
  1417.     printf("   :BCC $");      hexprn(pc+2+code,4);        printf("   ");
  1418.     prnspc(RTScounter);       printf(";Branch on C ");    binprn((C & 1),1);
  1419.     printf(" clear");
  1420.     prnspc(17 - RTScounter);
  1421.     printf("'");              statprn();                  printf("'\n");
  1422.   }
  1423. }
  1424.  
  1425. BCSrel()
  1426. {
  1427.   int pc,
  1428.   code;
  1429.   pc = PC-1;
  1430.   code = loadOp();
  1431.   code = (code>127)?(code-256):code;
  1432.   if (C == 1)
  1433.     PC+=code;
  1434.   if (trace)
  1435.   {
  1436.     if (antalarg > 2)
  1437.       botomline();
  1438.     hexprn(pc,4);             printf("-B0 ");             hexprn(code,2);
  1439.     printf("   :BCS $");      hexprn(pc+2+code,4);        printf("   ");
  1440.     prnspc(RTScounter);       printf(";Branch on C ");    binprn((C & 1),1);
  1441.     printf(" set");
  1442.     prnspc(19 - RTScounter);
  1443.     printf("'");              statprn();                  printf("'\n");
  1444.   }
  1445. }
  1446.  
  1447. BEQrel()
  1448. {
  1449.   int pc,
  1450.   code;
  1451.   pc = PC-1;
  1452.   code = loadOp();
  1453.   code = (code>127)?(code-256):code;
  1454.   if (Z == 1)
  1455.     PC+=code;
  1456.   if (trace)
  1457.   {
  1458.     if (antalarg > 2)
  1459.       botomline();
  1460.     hexprn(pc,4);             printf("-F0 ");             hexprn(code,2);
  1461.     printf("   :BEQ $");      hexprn(pc+2+code,4);        printf("   ");
  1462.     prnspc(RTScounter);       printf(";Branch on Z ");    binprn((Z & 1),1);
  1463.     printf(" set");
  1464.     prnspc(19 - RTScounter);
  1465.     printf("'");              statprn();                  printf("'\n");
  1466.   }
  1467. }
  1468.  
  1469. BITabs()
  1470. {
  1471.   int pc,
  1472.       code,
  1473.       code2,
  1474.       codel,
  1475.       codeh;
  1476.   pc = PC-1;
  1477.   codel = loadOp();                codeh = loadOp();
  1478.   code = ((A & 0xFF) & (code2=loadCo(codeh,codel)));
  1479.   N = ((code & 0x80) != 0);
  1480.   V = ((code & 0x40) != 0);
  1481.   Z = code == 0;
  1482.   if (trace)
  1483.   {
  1484.     if (antalarg > 2)
  1485.       botomline();
  1486.     hexprn(pc,4);            printf("-2C ");
  1487.     hexprn(codel,2);         printf(" ");                hexprn(codeh,2);
  1488.     printf(":BIT $");        hexprn(codeh,2);            hexprn(codel,2);
  1489.     printf("   ");           prnspc(RTScounter);
  1490.     printf(";Test $");       hexprn(codeh,2);            hexprn(codel,2);
  1491.     printf(" [");            hexprn(code2,2);
  1492.     printf("] with A ");     hexprn(A,2);
  1493.     prnspc(11 - RTScounter);
  1494.     printf("'");          statprn();                  printf("'\n");
  1495.   }
  1496. }
  1497.  
  1498. BNErel()
  1499. {
  1500.   int pc,
  1501.   code;
  1502.   pc = PC-1;
  1503.   code = loadOp();
  1504.   code = (code>127)?(code-256):code;
  1505.   if (Z == 0)
  1506.     PC+=code;
  1507.   if (trace)
  1508.   {
  1509.     if (antalarg > 2)
  1510.       botomline();
  1511.     hexprn(pc,4);             printf("-D0 ");             hexprn(code,2);
  1512.     printf("   :BNE $");      hexprn(pc+2+code,4);        printf("   ");
  1513.     prnspc(RTScounter);
  1514.     printf(";Branch on Z ");  binprn(Z,1);                printf(" clear");
  1515.     prnspc(17 - RTScounter);
  1516.     printf("'");              statprn();                  printf("'\n");
  1517.   }
  1518. }
  1519.  
  1520. BMIrel()
  1521. {
  1522.   int pc,
  1523.   code;
  1524.   pc = PC-1;
  1525.   code = loadOp();
  1526.   code = (code>127)?(code-256):code;
  1527.   if (N == 1)
  1528.     PC+=code;
  1529.   if (trace)
  1530.   {
  1531.     if (antalarg > 2)
  1532.       botomline();
  1533.     hexprn(pc,4);             printf("-30 ");             hexprn(code,2);
  1534.     printf("   :BMI $");      hexprn(pc+2+code,4);        printf("   ");
  1535.     prnspc(RTScounter);
  1536.     printf(";Branch on N ");  binprn(N,1);                printf(" set");
  1537.     prnspc(19 - RTScounter);
  1538.     printf("'");              statprn();                  printf("'\n");
  1539.   }
  1540. }
  1541.  
  1542. BPLrel()
  1543. {
  1544.   int pc,
  1545.   code;
  1546.   pc = PC-1;
  1547.   code = loadOp();
  1548.   code = (code>127)?(code-256):code;
  1549.   if (N == 0)
  1550.     PC+=code;
  1551.   if (trace)
  1552.   {
  1553.     if (antalarg > 2)
  1554.       botomline();
  1555.     hexprn(pc,4);             printf("-10 ");             hexprn(code,2);
  1556.     printf("   :BPL $");      hexprn(pc+2+code,4);        printf("   ");
  1557.     prnspc(RTScounter);
  1558.     printf(";Branch on N ");  binprn(C,1);                printf(" clear");
  1559.     prnspc(17 - RTScounter);
  1560.     printf("'");              statprn();                  printf("'\n");
  1561.   }
  1562. }
  1563.  
  1564. BRK()
  1565. {
  1566.   int pc,
  1567.       code;
  1568.   pc = PC-1;
  1569.   code=PCH;  pushS(code);
  1570.   code=PCL;  pushS(code);
  1571.   I = 1;     B = 1;
  1572.   code=P;    pushS(code);
  1573.   PCL = MEMORY [0xFFFE];
  1574.   PCH = MEMORY [0xFFFF];
  1575.   if (trace)
  1576.   {
  1577.     if (antalarg > 2)
  1578.       botomline();
  1579.     hexprn(pc,4);             printf("-00 ");             printf("  ");
  1580.     printf("   :BRK");        printf("         ");
  1581.     prnspc(RTScounter);
  1582.     printf(";Force break");
  1583.     prnspc(25 - RTScounter);
  1584.     printf("'");              statprn();                  printf("'\n");
  1585.   }
  1586. }
  1587.  
  1588.  
  1589. CLC()
  1590. {
  1591.   int pc;
  1592.   pc = PC-1;
  1593.   C = 0;
  1594.   if (trace)
  1595.   {
  1596.     if (antalarg > 2)
  1597.       botomline();
  1598.     hexprn(pc,4);             printf("-18 ");             printf("  ");
  1599.     printf("   :CLC");        printf("         ");
  1600.     prnspc(RTScounter);
  1601.     printf(";Clear carry flag");
  1602.     prnspc(20 - RTScounter);
  1603.     printf("'");              statprn();                  printf("'\n");
  1604.   }
  1605. }
  1606.  
  1607. CLD()
  1608. {
  1609.   int pc;
  1610.   pc = PC-1;
  1611.   D=0;
  1612.   if (trace)
  1613.   {
  1614.     if (antalarg > 2)
  1615.       botomline();
  1616.     hexprn(pc,4);             printf("-D8 ");             printf("  ");
  1617.     printf("   :CLD");        printf("         ");
  1618.     prnspc(RTScounter);
  1619.     printf(";Clear decimal mode");
  1620.     prnspc(18 - RTScounter);
  1621.     printf("'");              statprn();                  printf("'\n");
  1622.   }
  1623. }
  1624.  
  1625. CMPabs_y()
  1626. {
  1627.   int pc,
  1628.       code,
  1629.       codel,
  1630.       codeh,
  1631.       codel2,
  1632.       codeh2,
  1633.       ansv;
  1634.   pc = PC-1;
  1635.   Y = (Y & 0xFF);
  1636.   codel = loadOp();            codeh = loadOp();
  1637.   codel2 = codel + Y;          codeh2 = codeh + ((codel2 >> 8) & 1);
  1638.   codel2 &= 0xFF;              codeh2 &= 0xFF;
  1639.   code = loadCo(codeh2,codel2);
  1640.   ansv = (A & 0xFF) - code;
  1641.   N = ((ansv & 0xFF) >> 7);
  1642.   Z =  (ansv & 0xFF) == 0;
  1643.   C = ((A & 0xFF) >= code);
  1644.   if (trace)
  1645.   {
  1646.     if (antalarg > 2)
  1647.       botomline();
  1648.     hexprn(pc,4);             printf("-D9 ");
  1649.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  1650.     printf(":CMP $");         hexprn(codeh,2);            hexprn(codel,2);
  1651.     printf(",Y ");
  1652.     prnspc(RTScounter);
  1653.     printf(";Compare ");      hexprn(codeh2,2);           hexprn(codel2,2);
  1654.     printf(" [");             hexprn(code,2);
  1655.     printf("] with A ");      hexprn(A,2);                printf(" ");
  1656.     prnspc(8 - RTScounter);
  1657.     printf("'");              statprn();                  printf("'\n");
  1658.   }
  1659. }
  1660.  
  1661. CMPimm()
  1662. {
  1663.   int pc,
  1664.       code,
  1665.       ansv;
  1666.   pc = PC-1;
  1667.   code = loadOp();
  1668.   ansv = (A & 0xFF) - code;
  1669.   N = ((ansv & 0xFF) >> 7);
  1670.   Z =  (ansv & 0xFF) == 0;
  1671.   C = ((A & 0xFF) >= code);
  1672.   if (trace)
  1673.   {
  1674.     if (antalarg > 2)
  1675.       botomline();
  1676.     hexprn(pc,4);             printf("-C9 ");             hexprn(code,2);
  1677.     printf("   :CMP #$");     hexprn(code,2);             printf("    ");
  1678.     prnspc(RTScounter);
  1679.     printf(";Compare #");     hexprn(code,2);
  1680.     printf(" with A ");       hexprn(A,2);                printf(" ");
  1681.     prnspc(14 - RTScounter);
  1682.     printf("'");              statprn();                  printf("'\n");
  1683.   }
  1684. }
  1685.  
  1686. CMPzpa()
  1687. {
  1688.   int pc,
  1689.       code,
  1690.       codel,
  1691.       ansv;
  1692.   pc = PC-1;
  1693.   codel = loadOp();
  1694.   ansv = (A & 0xFF) - (code = loadCo(0x00,codel));
  1695.   N = ((ansv & 0xFF) >> 7);
  1696.   Z =  (ansv & 0xFF) == 0;
  1697.   C = ((A & 0xFF) >= code);
  1698.   if (trace)
  1699.   {
  1700.     if (antalarg > 2)
  1701.       botomline();
  1702.     hexprn(pc,4);             printf("-C5 ");             hexprn(codel,2);
  1703.     printf("   :CMP $");      hexprn(codel,2);            printf("     ");
  1704.     prnspc(RTScounter);
  1705.     printf(";Compare ");      hexprn(codel,2);
  1706.     printf(" [");             hexprn(code,2);
  1707.     printf("] with A ");      hexprn(A,2);                printf(" ");
  1708.     prnspc(10 - RTScounter);
  1709.     printf("'");              statprn();                  printf("'\n");
  1710.   }
  1711. }
  1712.  
  1713. CPXimm()
  1714. {
  1715.   int pc,
  1716.       code,
  1717.       ansv;
  1718.   pc = PC-1;
  1719.   code = loadOp();
  1720.   ansv = (X & 0xFF) - code;
  1721.   N = ((ansv & 0xFF) >> 7);
  1722.   Z =  (ansv & 0xFF) == 0;
  1723.   C = ((X & 0xFF) >= code);
  1724.   if (trace)
  1725.   {
  1726.     if (antalarg > 2)
  1727.       botomline();
  1728.     hexprn(pc,4);             printf("-E0 ");             hexprn(code,2);
  1729.     printf("   :CPX #$");     hexprn(code,2);             printf("    ");
  1730.     prnspc(RTScounter);
  1731.     printf(";Compare #");     hexprn(code,2);
  1732.     printf(" with X ");       hexprn(A,2);                printf(" ");
  1733.     prnspc(14 - RTScounter);
  1734.     printf("'");              statprn();                  printf("'\n");
  1735.   }
  1736. }
  1737.  
  1738. CPYimm()
  1739. {
  1740.   int pc,
  1741.       code,
  1742.       ansv;
  1743.   pc = PC-1;
  1744.   code = loadOp();
  1745.   ansv = (Y & 0xFF) - code;
  1746.   N = ((ansv & 0xFF) >> 7);
  1747.   Z =  (ansv & 0xFF) == 0;
  1748.   C = ((Y & 0xFF) >= code);
  1749.   if (trace)
  1750.   {
  1751.     if (antalarg > 2)
  1752.       botomline();
  1753.     hexprn(pc,4);             printf("-C0 ");             hexprn(code,2);
  1754.     printf("   :CPY #$");     hexprn(code,2);             printf("    ");
  1755.     prnspc(RTScounter);
  1756.     printf(";Compare #");     hexprn(code,2);
  1757.     printf(" with Y ");       hexprn(Y,2);                printf(" ");
  1758.     prnspc(14 - RTScounter);
  1759.     printf("'");              statprn();                  printf("'\n");
  1760.   }
  1761. }
  1762.  
  1763. CPYzpa()
  1764. {
  1765.   int pc,
  1766.       code,
  1767.       codel,
  1768.       ansv;
  1769.   pc = PC-1;
  1770.   codel = loadOp();
  1771.   ansv = (Y & 0xFF) - (code = loadCo(0x00,codel));
  1772.   N = (ansv & 0x80) != 0;
  1773.   Z = (ansv & 0xFF) == 0;
  1774.   C = ((Y & 0xFF) >= code);
  1775.   if (trace)
  1776.   {
  1777.     if (antalarg > 2)
  1778.       botomline();
  1779.     hexprn(pc,4);             printf("-C4 ");             hexprn(codel,2);
  1780.     printf("   :CPY $");      hexprn(codel,2);            printf("     ");
  1781.     prnspc(RTScounter);
  1782.     printf(";Compare ");      hexprn(codel,2);
  1783.     printf(" [");             hexprn(code,2);
  1784.     printf("] with Y ");      hexprn(Y,2);                printf(" ");
  1785.     prnspc(10 - RTScounter);
  1786.     printf("'");              statprn();                  printf("'\n");
  1787.   }
  1788. }
  1789.  
  1790. DECzpa()
  1791. {
  1792.   int pc,
  1793.       code,
  1794.       code2,
  1795.       codel;
  1796.   pc = PC-1;
  1797.   codel = loadOp();
  1798.   code = loadCo(0x00,codel);
  1799.   code2 = ((code | 0x100) - 1) & 0xFF;
  1800.   saveCo(0x00,codel,code2);
  1801.   N = (code2 & 0x80) != 0;
  1802.   Z = (code2 & 0xFF) == 0;
  1803.   if (trace)
  1804.   {
  1805.     if (antalarg > 2)
  1806.       botomline();
  1807.     hexprn(pc,4);             printf("-C6 ");             hexprn(codel,2);
  1808.     printf("   :DEC $");      hexprn(codel,2);            printf("     ");
  1809.     prnspc(RTScounter);
  1810.     printf(";Decrement ");    hexprn(codel,2);
  1811.     printf(" [");             hexprn(code,2);             printf("] by one");
  1812.     prnspc(12 - RTScounter);
  1813.     printf("'");              statprn();                  printf("'\n");
  1814.   }
  1815. }
  1816.  
  1817. DEX()
  1818. {
  1819.   int pc,
  1820.       x;
  1821.   pc = PC-1;
  1822.   x = X;
  1823.   X = ((X | 0x100) - 1) & 0xFF;
  1824.   N = (X & 0x80) != 0;
  1825.   Z = (X & 0xFF) == 0;
  1826.   if (trace)
  1827.   {
  1828.     if (antalarg > 2)
  1829.       botomline();
  1830.     hexprn(pc,4);             printf("-CA ");             printf("  ");
  1831.     printf("   :DEX");        printf("         ");
  1832.     prnspc(RTScounter);
  1833.     printf(";Decrement index X ");
  1834.                               hexprn(x,2);                printf(" by one");
  1835.     prnspc(9 - RTScounter);
  1836.     printf("'");              statprn();                  printf("'\n");
  1837.   }
  1838. }
  1839.  
  1840. DEY()
  1841. {
  1842.   int pc,
  1843.       y;
  1844.   pc = PC-1;
  1845.   y = Y;
  1846.   Y = ((Y | 0x100) - 1) & 0xFF;
  1847.   N = (Y & 0x80) != 0;
  1848.   Z = (Y & 0xFF) == 0;
  1849.   if (trace)
  1850.   {
  1851.     if (antalarg > 2)
  1852.       botomline();
  1853.     hexprn(pc,4);             printf("-88 ");             printf("  ");
  1854.     printf("   :DEY");        printf("         ");
  1855.     prnspc(RTScounter);
  1856.     printf(";Decrement index Y ");
  1857.                               hexprn(y,2);                printf(" by one");
  1858.     prnspc(9 - RTScounter);
  1859.     printf("'");              statprn();                  printf("'\n");
  1860.   }
  1861. }
  1862.  
  1863. EORimm()
  1864. {
  1865.   int pc,
  1866.       code,
  1867.       a;
  1868.   pc = PC-1;
  1869.   code = loadOp();
  1870.   a = A;
  1871.   A =  ((A & 0xFF) | code) - ((A & 0xFF) & code);
  1872.   N = ((A & 0xFF) >> 7);
  1873.   Z =  (A & 0xFF) == 0;
  1874.   if (trace)
  1875.   {
  1876.     if (antalarg > 2)
  1877.       botomline();
  1878.     hexprn(pc,4);             printf("-49 ");             hexprn(code,2);
  1879.     printf("   :EOR #$");     hexprn(code,2);             printf("    ");
  1880.     prnspc(RTScounter);
  1881.     printf(";Eor #");         hexprn(code,2);
  1882.     printf(" with A ");       hexprn(a,2);                printf(" ");
  1883.     prnspc(18 - RTScounter);
  1884.     printf("'");              statprn();                  printf("'\n");
  1885.   }
  1886. }
  1887.  
  1888. INCzpa()
  1889. {
  1890.   int pc,
  1891.       eb,
  1892.       code,
  1893.       codel,
  1894.       mem;
  1895.   pc = PC-1;
  1896.   codel = loadOp();
  1897.   saveCo(0x00,codel,(code = loadCo(0x00,codel))+1);
  1898.   N = (code & 0x80) == 80;
  1899.   Z = code == 0x00;
  1900.   if (trace)
  1901.   {
  1902.     if (antalarg > 2)
  1903.       botomline();
  1904.     hexprn(pc,4);            printf("-E6 ");              hexprn(codel,2);
  1905.     printf("   :INC $");     hexprn(codel,2);             printf("     ");
  1906.     prnspc(RTScounter);
  1907.     printf(";Increment $");  hexprn(codel,2);
  1908.     printf(" [");            hexprn(code,2);            printf("] by one");
  1909.     prnspc(11 - RTScounter);
  1910.     printf("'");             statprn();                   printf("'\n");
  1911.   }
  1912. }
  1913.  
  1914. INX()
  1915. {
  1916.   int pc,
  1917.       x;
  1918.   pc = PC-1;
  1919.   x = X;
  1920.   X = (X & 0xFF) + 1;
  1921.   N = (X & 0x80) != 0;
  1922.   Z = (X & 0xFF) == 0;
  1923.   if (trace)
  1924.   {
  1925.     if (antalarg > 2)
  1926.       botomline();
  1927.     hexprn(pc,4);             printf("-E8 ");             printf("  ");
  1928.     printf("   :INX");        printf("         ");
  1929.     prnspc(RTScounter);
  1930.     printf(";increment index X ");
  1931.                               hexprn(x,2);                printf(" by one");
  1932.     prnspc(9 - RTScounter);
  1933.     printf("'");              statprn();                  printf("'\n");
  1934.   }
  1935. }
  1936.  
  1937. INY()
  1938. {
  1939.   int pc,
  1940.       y;
  1941.   pc = PC-1;
  1942.   y = Y;
  1943.   Y = (Y & 0xFF) + 1;
  1944.   N = (Y & 0x80) != 0;
  1945.   Z = (Y & 0xFF) == 0;
  1946.   if (trace)
  1947.   {
  1948.     if (antalarg > 2)
  1949.       botomline();
  1950.     hexprn(pc,4);             printf("-C8 ");             printf("  ");
  1951.     printf("   :INY");        printf("         ");
  1952.     prnspc(RTScounter);
  1953.     printf(";increment index Y ");
  1954.                               hexprn(y,2);                printf(" by one");
  1955.     prnspc(9 - RTScounter);
  1956.     printf("'");              statprn();                  printf("'\n");
  1957.   }
  1958. }
  1959.  
  1960. JMPabs()
  1961. {
  1962.   int codeh,
  1963.       codel,
  1964.       pc;
  1965.   pc = PC-1;
  1966.   codel = loadOp();  codeh = loadOp();
  1967.   PCL = codel;       PCH = codeh;
  1968.   if (trace)
  1969.   {
  1970.     if (antalarg > 2)
  1971.       botomline();
  1972.     hexprn(pc,4);             printf("-4C ");
  1973.     hexprn(PCL,2);            printf(" ");                hexprn(PCH,2);
  1974.     printf(":JMP $");         hexprn(PC,4);               printf("   ");
  1975.     prnspc(RTScounter);       printf(";Jump to ");        hexprn(PC,4);
  1976.     prnspc(24 - RTScounter);
  1977.     printf("'");              statprn();                  printf("'\n");
  1978.   }
  1979. }
  1980.  
  1981. JMPind()
  1982. {
  1983.   int codeh,
  1984.       codel,
  1985.       codeh2,
  1986.       codel2,
  1987.       pc;
  1988.   pc = PC-1;
  1989.   codel = loadOp();           codeh = loadOp();
  1990.   codel2= codel +1;           codeh2= codeh + (codel2>>8);
  1991.   PCL = loadCo(codeh,codel);  PCH = loadCo((codeh2 & 0xFF),(codel2 & 0xFF));
  1992.   if (trace)
  1993.   {
  1994.     if (antalarg > 2)
  1995.       botomline();
  1996.     hexprn(pc,4);             printf("-6C ");
  1997.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  1998.     printf(":JMP (");         hexprn(codeh,2);            hexprn(codel,2);
  1999.     printf(")  ");            prnspc(RTScounter);
  2000.     printf(";Jump to ");      hexprn(PC,4);
  2001.     prnspc(24 - RTScounter);
  2002.     printf("'");              statprn();                  printf("'\n");
  2003.   }
  2004. }
  2005.  
  2006. JSRabs()
  2007. {
  2008.   int pc,
  2009.   codel,
  2010.   codeh;
  2011.   pc = PC-1;
  2012.   codel = loadOp();  codeh = loadOp();
  2013.   PC --;
  2014.   pushS(PCH);        pushS(PCL);
  2015.   PCL = codel;       PCH = codeh;
  2016.   RTScounter ++;     STACKcounter = S;
  2017.   if (trace)
  2018.   {
  2019.     if (antalarg > 2)
  2020.       botomline();
  2021.     hexprn(pc,4);             printf("-20 ");
  2022.     hexprn(PCL,2);            printf(" ");                hexprn(PCH,2);
  2023.     printf(":JSR ");          hexprn(PC,4);               printf("    ");
  2024.     prnspc(RTScounter);
  2025.     printf(";Jump to subrutine ");                        hexprn(PC,4);
  2026.     prnspc(14 - RTScounter);
  2027.     printf("'");              statprn();                  printf("'\n");
  2028.   }
  2029. }
  2030.  
  2031. LDAabs()
  2032. {
  2033.   int pc,
  2034.       codeh,
  2035.       codel;
  2036.   pc = PC-1;
  2037.   codel = loadOp();  codeh = loadOp();
  2038.   A = loadCo(codeh,codel);
  2039.   N = ((A & 0xFF) >> 7);
  2040.   Z =  (A & 0xFF) == 0;
  2041.   if (trace)
  2042.   {
  2043.     if (antalarg > 2)
  2044.       botomline();
  2045.     hexprn(pc,4);             printf("-AD ");
  2046.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  2047.     printf(":LDA $");         hexprn(codeh,2);            hexprn(codel,2);
  2048.     printf("   ");            prnspc(RTScounter);
  2049.     printf(";Load accumulator with ");                    hexprn(A,2);
  2050.     prnspc(12 - RTScounter);
  2051.     printf("'");              statprn();                  printf("'\n");
  2052.   }
  2053. }
  2054.  
  2055. LDAabs_x()
  2056. {
  2057.   int pc,
  2058.       codeh,
  2059.       codel,
  2060.       codeh2,
  2061.       codel2;
  2062.   pc = PC-1;
  2063.   X &= 0xFF;
  2064.   codel = loadOp();         codeh = loadOp();
  2065.   codel2 = codel + X;       codeh2 = codeh + ((codel2 >> 8) & 1);
  2066.   codel2 &= 0xFF;           codeh2 &= 0xFF;
  2067.   A = loadCo(codeh2,codel2);
  2068.   N = ((A & 0xFF) >> 7);
  2069.   Z =  (A & 0xFF) == 0;
  2070.   if (trace)
  2071.   {
  2072.     if (antalarg > 2)
  2073.       botomline();
  2074.     hexprn(pc,4);             printf("-BD ");
  2075.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  2076.     printf(":LDA ($");        hexprn(codeh,2);            hexprn(codel,2);
  2077.     printf("),X");            prnspc(RTScounter);
  2078.     printf(";Load accumulator with ");
  2079.                               hexprn(codeh2,2);           hexprn(codel2,2);
  2080.     printf(" [");             hexprn(A,2);                printf("]");
  2081.     prnspc(5 - RTScounter);
  2082.     printf("'");              statprn();                  printf("'\n");
  2083.   }
  2084. }
  2085.  
  2086. LDAabs_y()
  2087. {
  2088.   int pc,
  2089.       codeh,
  2090.       codel,
  2091.       codeh2,
  2092.       codel2;
  2093.   pc = PC-1;
  2094.   Y &= 0xFF;
  2095.   codel = loadOp();         codeh = loadOp();
  2096.   codel2 = codel + Y;       codeh2 = codeh + ((codel2 >> 8) & 1);
  2097.   codel2 &= 0xFF;           codeh2 &= 0xFF;
  2098.   A = loadCo(codeh2,codel2);
  2099.   N = ((A & 0xFF) >> 7);
  2100.   Z =  (A & 0xFF) == 0;
  2101.   if (trace)
  2102.   {
  2103.     if (antalarg > 2)
  2104.       botomline();
  2105.     hexprn(pc,4);             printf("-B9 ");
  2106.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  2107.     printf(":LDA (");         hexprn(codeh,2);            hexprn(codel,2);
  2108.     printf("),Y");            prnspc(RTScounter);
  2109.     printf(";Load accumulator with ");
  2110.                               hexprn(codeh2,2);            hexprn(codel2,2);
  2111.     printf(" [");             hexprn(A,2);                printf("]");
  2112.     prnspc(5 - RTScounter);
  2113.     printf("'");              statprn();                  printf("'\n");
  2114.   }
  2115. }
  2116.  
  2117. LDAimm()
  2118. {
  2119.   int pc,
  2120.       code;
  2121.   pc = PC-1;
  2122.   code = loadOp();
  2123.   A=code;
  2124.   N = ((code&0xFF)>>7);
  2125.   Z = (code&0xFF)==0;
  2126.   if (trace)
  2127.   {
  2128.     if (antalarg > 2)
  2129.       botomline();
  2130.     hexprn(pc,4);             printf("-A9 ");             hexprn(code,2);
  2131.     printf("   :LDA #$");     hexprn(code,2);             printf("    ");
  2132.     prnspc(RTScounter);
  2133.     printf(";Load accumulator with #");                   hexprn(A,2);
  2134.     prnspc(11 - RTScounter);
  2135.     printf("'");              statprn();                  printf("'\n");
  2136.   }
  2137. }
  2138.  
  2139. LDAind_x()
  2140. {
  2141.   int pc,
  2142.       a,
  2143.       code,
  2144.       codel,
  2145.       codeh,
  2146.       codel2,
  2147.       codeh2,
  2148.       codel3,
  2149.       codeh3;
  2150.   pc = PC-1;
  2151.   X &= 0xFF;
  2152.   code = loadOp();
  2153.   codel = code + X;                codeh = 0x00;
  2154.   codel &= 0xFF;
  2155.   codel2 = codel + 1;              codeh2 = 0x00;
  2156.   codel2 &= 0xFF;
  2157.   codel3 = loadCo(codeh,codel);    codeh3 = loadCo(codeh2,codel2);
  2158.   A = loadCo(codeh3,codel3);
  2159.   if (trace)
  2160.   {
  2161.     if (antalarg > 2)
  2162.       botomline();
  2163.     hexprn(pc,4);             printf("-A1 ");             hexprn(code,2);
  2164.     printf("   :LDA ($");     hexprn(code,2);             printf(",X) ");
  2165.     prnspc(RTScounter);
  2166.     printf(";Load A ind X "); hexprn(Y,2);
  2167.     printf("from ");          hexprn(codeh3,2);           hexprn(codel3,2);
  2168.     printf(" [");             hexprn(A,2);                printf("]");
  2169.     prnspc(7 - RTScounter);
  2170.     printf("'");              statprn();                  printf("'\n");
  2171.   }
  2172. }
  2173.  
  2174. LDAind_y()
  2175. {
  2176.   int pc,
  2177.       a,
  2178.       code,
  2179.       codel,
  2180.       codeh,
  2181.       codel2,
  2182.       codeh2,
  2183.       codel3,
  2184.       codeh3;
  2185.   pc = PC-1;
  2186.   Y &= 0xFF;
  2187.   code = loadOp();
  2188.   codel = code+1;                  codeh = 0x00;
  2189.   codel &= 0xFF;
  2190.   codel2 = loadCo(0x00,code);      codeh2 = loadCo(codeh,codel);
  2191.   codel3 = codel2 + Y;             codeh3 = codeh2 + ((codel3 >>8) & 1);
  2192.   codel3 &= 0xFF;                  codeh3 &= 0xFF;
  2193.   A = loadCo(codeh3,codel3);
  2194.   if (trace)
  2195.   {
  2196.     if (antalarg > 2)
  2197.       botomline();
  2198.     hexprn(pc,4);             printf("-B1 ");             hexprn(code,2);
  2199.     printf("   :LDA ($");     hexprn(code,2);             printf("),Y ");
  2200.     prnspc(RTScounter);
  2201.     printf(";Load A with Y ");hexprn(Y,2);
  2202.     printf("from ");          hexprn(codeh3,2);           hexprn(codel3,2);
  2203.     printf(" [");             hexprn(A,2);                printf("]");
  2204.     prnspc(6 - RTScounter);
  2205.     printf("'");              statprn();                  printf("'\n");
  2206.   }
  2207. }
  2208.  
  2209. LDAzpa()
  2210. {
  2211.   int pc,
  2212.       code;
  2213.   pc = PC-1;
  2214.   code = loadOp();
  2215.   A = loadCo(0x00,code);
  2216.   N = (A & 0x80) !=0;
  2217.   Z = (A & 0xFF) ==0;
  2218.   if (trace)
  2219.   {
  2220.     if (antalarg > 2)
  2221.       botomline();
  2222.     hexprn(pc,4);             printf("-A5 ");             hexprn(code,2);
  2223.     printf("   :LDA $");      hexprn(0x00,2);             hexprn(code,2);
  2224.     printf("   ");            prnspc(RTScounter);
  2225.     printf(";Load $");        hexprn(code,2);
  2226.     printf(" with accumulator ");                         hexprn(A,2);
  2227.     prnspc(8 - RTScounter);
  2228.     printf("'");              statprn();                  printf("'\n");
  2229.   }
  2230. }
  2231.  
  2232. LDAzpa_x()
  2233. {
  2234.   int pc,
  2235.       codeh,
  2236.       codel,
  2237.       codeh2,
  2238.       codel2;
  2239.   pc = PC-1;
  2240.   X &= 0xFF;
  2241.   codel = loadOp();         codeh = 0x00;
  2242.   codel2 = codel + X;       codeh2 = 0x00;
  2243.   codel2 &= 0xFF;
  2244.   A = loadCo((codeh2 & 0xFF),(codel2 & 0xFF));
  2245.   N = (A & 0x80) != 0;
  2246.   Z = (A & 0xFF) == 0;
  2247.   if (trace)
  2248.   {
  2249.     if (antalarg > 2)
  2250.       botomline();
  2251.     hexprn(pc,4);             printf("-B5 ");             hexprn(codel,2);
  2252.     printf("   :LDA $");      hexprn(codel,2);
  2253.     printf(",X  ");           prnspc(RTScounter);
  2254.     printf(";Load accumulator with ");
  2255.                               hexprn(codeh2,2);           hexprn(codel2,2);
  2256.     printf(" [");             hexprn(A,2);                printf("]");
  2257.     prnspc(7 - RTScounter);
  2258.     printf("'");              statprn();                  printf("'\n");
  2259.   }
  2260. }
  2261.  
  2262. LDXimm()
  2263. {
  2264.   int pc;
  2265.   pc = PC-1;
  2266.   X = loadOp();
  2267.   N = ((X & 0xFF) >> 7);
  2268.   Z =  (X & 0xFF) == 0;
  2269.   if (trace)
  2270.   {
  2271.     if (antalarg > 2)
  2272.       botomline();
  2273.     hexprn(pc,4);             printf("-A2 ");             hexprn(X,2);
  2274.     printf("   :LDX #$");     hexprn(X,2);                printf("    ");
  2275.     prnspc(RTScounter);
  2276.     printf(";Load index,X with #");                       hexprn(X,2);
  2277.     prnspc(15 - RTScounter);
  2278.     printf("'");              statprn();                  printf("'\n");
  2279.   }
  2280. }
  2281.  
  2282. LDXzpa()
  2283. {
  2284.   int pc,
  2285.       code;
  2286.   pc = PC-1;
  2287.   code = loadOp();
  2288.   X = loadCo(0x00,code);
  2289.   N = ((code&0xFF)>>7);
  2290.   Z = (code&0xFF)==0;
  2291.   if (trace)
  2292.   {
  2293.     if (antalarg > 2)
  2294.       botomline();
  2295.     hexprn(pc,4);             printf("-A6 ");             hexprn(code,2);
  2296.     printf("   :LDX $");      hexprn(0x00,2);             hexprn(code,2);
  2297.     printf("   ");            prnspc(RTScounter);
  2298.     printf(";Load index X with ");                        hexprn(X,2);
  2299.     prnspc(16 - RTScounter);
  2300.     printf("'");              statprn();                  printf("'\n");
  2301.   }
  2302. }
  2303.  
  2304. LDYimm()
  2305. {
  2306.   int pc;
  2307.   pc = PC-1;
  2308.   Y = loadOp();
  2309.   N = ((Y & 0xFF) >> 7);
  2310.   Z =  (Y & 0xFF) == 0;
  2311.   if (trace)
  2312.   {
  2313.     if (antalarg > 2)
  2314.       botomline();
  2315.     hexprn(pc,4);             printf("-A0 ");             hexprn(Y,2);
  2316.     printf("   :LDY #$");     hexprn(Y,2);                printf("    ");
  2317.     prnspc(RTScounter);
  2318.     printf(";Load index,Y with #");                       hexprn(Y,2);
  2319.     prnspc(15 - RTScounter);
  2320.     printf("'");              statprn();                  printf("'\n");
  2321.   }
  2322. }
  2323.  
  2324. LDYzpa()
  2325. {
  2326.   int pc,
  2327.       code;
  2328.   pc = PC-1;
  2329.   code = loadOp();
  2330.   Y = loadCo(0x00,code);
  2331.   N = ((code&0xFF)>>7);
  2332.   Z = (code&0xFF)==0;
  2333.   if (trace)
  2334.   {
  2335.     if (antalarg > 2)
  2336.       botomline();
  2337.     hexprn(pc,4);             printf("-A4 ");             hexprn(code,2);
  2338.     printf("   :LDY $");      hexprn(0x00,2);             hexprn(code,2);
  2339.     printf("   ");            prnspc(RTScounter);
  2340.     printf(";Load index Y with ");                        hexprn(Y,2);
  2341.     prnspc(16 - RTScounter);
  2342.     printf("'");              statprn();                  printf("'\n");
  2343.   }
  2344. }
  2345.  
  2346. LSRacc()
  2347. {
  2348.   int pc,
  2349.       a;
  2350.   pc = PC-1;
  2351.   C = (A & 1);
  2352.   a = A;
  2353.   A = (A & 0xFF) >> 1;
  2354.   N = 0;
  2355.   Z = (A & 0xFF) == 0;
  2356.   if (trace)
  2357.   {
  2358.     if (antalarg > 2)
  2359.       botomline();
  2360.     hexprn(pc,4);             printf("-4A   ");
  2361.     printf("   :LSR A   ");   printf("    ");
  2362.     prnspc(RTScounter);
  2363.     printf(";Shift right A ");hexprn((a & 0xFF),2);
  2364.     printf(" one bit to C "); binprn((C & 1),1);
  2365.     prnspc(5 - RTScounter);
  2366.     printf("'");              statprn();                  printf("'\n");
  2367.   }
  2368. }
  2369.  
  2370. ORAimm()
  2371. {
  2372.   int pc,
  2373.       code,
  2374.       a;
  2375.   pc = PC-1;
  2376.   code = loadOp();
  2377.   a = A;
  2378.   A =  (A & 0xFF) | code;
  2379.   N = ((A & 0xFF) >> 7);
  2380.   Z =  (A & 0xFF) == 0;
  2381.   if (trace)
  2382.   {
  2383.     if (antalarg > 2)
  2384.       botomline();
  2385.     hexprn(pc,4);             printf("-09 ");             hexprn(code,2);
  2386.     printf("   :ORA #$");     hexprn(code,2);             printf("    ");
  2387.     prnspc(RTScounter);
  2388.     printf(";Or #");          hexprn(code,2);
  2389.     printf(" with A ");       hexprn(a,2);
  2390.     prnspc(20 - RTScounter);
  2391.     printf("'");              statprn();                  printf("'\n");
  2392.   }
  2393. }
  2394.  
  2395. ORAzpa()
  2396. {
  2397.   int pc,
  2398.       code,
  2399.       codel,
  2400.       a;
  2401.   pc = PC-1;
  2402.   codel = loadOp();
  2403.   code = loadCo(0x00,codel);
  2404.   a = A;
  2405.   A =  (A & 0xFF) | code;
  2406.   N = ((A & 0xFF) >> 7);
  2407.   Z =  (A & 0xFF) == 0;
  2408.   if (trace)
  2409.   {
  2410.     if (antalarg > 2)
  2411.       botomline();
  2412.     hexprn(pc,4);             printf("-05 ");             hexprn(codel,2);
  2413.     printf("   :ORA $");      hexprn(codel,2);            printf("     ");
  2414.     prnspc(RTScounter);
  2415.     printf(";Or $");          hexprn(codel,2);
  2416.     printf(" [");             hexprn(code,2);
  2417.     printf("]) with A ");     hexprn(a,2);
  2418.     prnspc(14 - RTScounter);
  2419.     printf("'");              statprn();                  printf("'\n");
  2420.   }
  2421. }
  2422.  
  2423. PHA()
  2424. {
  2425.   int pc;
  2426.   pc = PC-1;
  2427.   pushS((A & 0xFF));
  2428.   if (trace)
  2429.   {
  2430.     if (antalarg > 2)
  2431.       botomline();
  2432.     hexprn(pc,4);             printf("-48 ");             printf("  ");
  2433.     printf("   :PHA");        printf("         ");
  2434.     prnspc(RTScounter);
  2435.     printf(";push A ");       hexprn(A,2);
  2436.     printf(" to stack pointer ");                         hexprn(S,2);
  2437.     prnspc(7 - RTScounter);
  2438.     printf("'");              statprn();                  printf("'\n");
  2439.   }
  2440. }
  2441.  
  2442. PHP()
  2443. {
  2444.   int pc;
  2445.   pc = PC-1;
  2446.   pushS((P & 0xFF));
  2447.   if (trace)
  2448.   {
  2449.     if (antalarg > 2)
  2450.       botomline();
  2451.     hexprn(pc,4);             printf("-08 ");             printf("  ");
  2452.     printf("   :PHP");        printf("         ");
  2453.     prnspc(RTScounter);
  2454.     printf(";push P ");       hexprn(P,2);
  2455.     printf(" to stack pointer ");                         hexprn(S,2);
  2456.     prnspc(7 - RTScounter);
  2457.     printf("'");              statprn();                  printf("'\n");
  2458.   }
  2459. }
  2460.  
  2461. PLA()
  2462. {
  2463.   int pc;
  2464.   pc = PC-1;
  2465.   A = pullS();
  2466.   N = ((A & 0xFF) >> 7);
  2467.   Z =  (A & 0xFF) == 0;
  2468.   if (trace)
  2469.   {
  2470.     if (antalarg > 2)
  2471.       botomline();
  2472.     hexprn(pc,4);             printf("-68 ");             printf("  ");
  2473.     printf("   :PLA");        printf("         ");
  2474.     prnspc(RTScounter);
  2475.     printf(";Pull A ");       hexprn(A,2);
  2476.     printf(" from stack-p "); hexprn(S,2);
  2477.     prnspc(11 - RTScounter);
  2478.     printf("'");              statprn();                  printf("'\n");
  2479.   }
  2480. }
  2481.  
  2482. PLP()
  2483. {
  2484.   int pc;
  2485.   pc = PC-1;
  2486.   P = pullS();
  2487.   if (trace)
  2488.   {
  2489.     if (antalarg > 2)
  2490.       botomline();
  2491.     hexprn(pc,4);             printf("-48 ");             printf("  ");
  2492.     printf("   :PLP");        printf("         ");
  2493.     prnspc(RTScounter);
  2494.     printf(";Pull P ");       hexprn(P,2);
  2495.     printf(" from stack-p "); hexprn(S,2);
  2496.     prnspc(11 - RTScounter);
  2497.     printf("'");              statprn();                  printf("'\n");
  2498.   }
  2499. }
  2500.  
  2501. ROLacc()
  2502. {
  2503.   int pc,
  2504.       code,
  2505.       codel,
  2506.       code2,
  2507.       a;
  2508.   pc = PC-1;
  2509.   a = A;
  2510.   code = A & 0xFF;
  2511.   code2 = ((code & 0xFF) << 1) | (C & 1);
  2512.   A = code2;
  2513.   N = (code2 & 0x80) != 0;
  2514.   Z = (code2 & 0xFF) == 0;
  2515.   C = (code2 & 0x100) != 0;
  2516.   if (trace)
  2517.   {
  2518.     if (antalarg > 2)
  2519.       botomline();
  2520.     hexprn(pc,4);             printf("-2A ");              hexprn(codel,2);
  2521.     printf("   :ROL Acc");    printf("     ");
  2522.     prnspc(RTScounter);       printf(";Rotate left ");     hexprn(a,2);
  2523.     printf(" from and to C ");binprn((C & 1),1);
  2524.     prnspc(6 - RTScounter);
  2525.     printf("'");              statprn();                   printf("'\n");
  2526.   }
  2527. }
  2528.  
  2529. ROLzpa()
  2530. {
  2531.   int pc,
  2532.       code,
  2533.       codel,
  2534.       code2;
  2535.   pc = PC-1;
  2536.   codel = loadOp();
  2537.   code = loadCo(0x00,codel);
  2538.   code2 = ((code & 0xFF) << 1) | (C & 1);
  2539.   saveCo(0x00,codel,code2);
  2540.   N = (code2 & 0x80) != 0;
  2541.   Z = (code2 & 0xFF) == 0;
  2542.   C = (code2 & 0x100) != 0;
  2543.   if (trace)
  2544.   {
  2545.     if (antalarg > 2)
  2546.       botomline();
  2547.     hexprn(pc,4);             printf("-26 ");              hexprn(codel,2);
  2548.     printf("   :ROL $");      hexprn(codel,2);             printf("     ");
  2549.     prnspc(RTScounter);       printf(";Rotate left ");     hexprn(code,2);
  2550.     printf(" from and to C ");binprn((C & 1),1);
  2551.     prnspc(6 - RTScounter);
  2552.     printf("'");              statprn();                   printf("'\n");
  2553.   }
  2554. }
  2555.  
  2556. RORacc()
  2557. {
  2558.   int pc,
  2559.       code,
  2560.       codel,
  2561.       code2,
  2562.       c;
  2563.   pc = PC-1;
  2564.   c = C;
  2565.   code = A;
  2566.   C = (code & 0x01);
  2567.   code2 = ((code & 0xFF) >> 1) | (c * 0x80);
  2568.   A = code2;
  2569.   N = (code2 & 0x80) != 0;
  2570.   Z = (code2 & 0xFF) == 0;
  2571.   if (trace)
  2572.   {
  2573.     if (antalarg > 2)
  2574.       botomline();
  2575.     hexprn(pc,4);             printf("-6A ");              hexprn(codel,2);
  2576.     printf("   :ROR $");      hexprn(codel,2);             printf("    ");
  2577.     prnspc(RTScounter);       printf(";Rotate left ");     hexprn(code,2);
  2578.     printf(" from and to C ");binprn((C & 1),1);
  2579.     prnspc(6 - RTScounter);
  2580.     printf("'");              statprn();                   printf("'\n");
  2581.   }
  2582. }
  2583.  
  2584. RTI()
  2585. {
  2586.   int pc,
  2587.       s;
  2588.   pc = PC-1;
  2589.   s = S;
  2590.   P = pullS();  PCL = pullS();  PCH = pullS();
  2591.   if (trace)
  2592.   {
  2593.     if (antalarg > 2)
  2594.       botomline();
  2595.     hexprn(pc,4);             printf("-40 ");             printf("  ");
  2596.     printf("   :RTI");        printf("         ");
  2597.     printf(";Pull P ");       hexprn(P,2);
  2598.     printf(" and PC ");       hexprn(PC,4);
  2599.     printf(" from S ");       hexprn(s,2);
  2600.     prnspc(5 - RTScounter);
  2601.     printf("'");              statprn();                  printf("'\n");
  2602.   }
  2603. }
  2604.  
  2605. RTS()
  2606. {
  2607.   int pc,
  2608.       s;
  2609.   pc = PC;
  2610.   s = S;
  2611.   PCL = pullS();PCH = pullS();
  2612.   PC ++;
  2613.   RTScounter --;
  2614.     if (RTScounter < -10)
  2615.     {
  2616.       code = 0xFF;
  2617.       return;
  2618.     }
  2619.  
  2620.   if (trace)
  2621.   {
  2622.     if (antalarg > 2)
  2623.       botomline();
  2624.  
  2625.     hexprn(pc,4);             printf("-60 ");             printf("  ");
  2626.     printf("   :RTS");        printf("         ");
  2627.     prnspc(RTScounter);
  2628.     printf(";Pull PC ");      hexprn(PC,4);
  2629.     printf(" from S ");       hexprn(s,2);
  2630.     prnspc(14 - RTScounter);
  2631.     printf("'");              statprn();                  printf("'\n");
  2632.   }
  2633.  
  2634.   if ((troff) && (tracepoint > RTScounter))
  2635.   {
  2636.     trace =1;
  2637.     troff =0;
  2638.     if (antalarg == 2)
  2639.       printf("\n");
  2640.   }
  2641. }
  2642.  
  2643. SBCimm()
  2644. {
  2645.   int pc,
  2646.   code,
  2647.   a,
  2648.   c;
  2649.   pc = PC-1;
  2650.   code = loadOp();
  2651.   a = A;
  2652.   c = C;
  2653.   A = ((A & 0xFF) | 0x100) - code - (C == 0);
  2654.   C = (A != 0x100);
  2655.   N = ((A & 0xFF)>>7);
  2656.   Z = (A & 0xFF)==0;
  2657.   V = (A - a) > 127;
  2658.   if (trace)
  2659.   {
  2660.     if (antalarg > 2)
  2661.       botomline();
  2662.     hexprn(pc,4);             printf("-E9 ");             hexprn(code,2);
  2663.     printf("   :SBC #$");     hexprn(code,2);             printf("    ");
  2664.     prnspc(RTScounter);
  2665.     printf(";Sbc #");         hexprn(code,2);
  2666.     printf(" to A ");         hexprn(a,2);
  2667.     printf(" with C ");       binprn(c,1);
  2668.     prnspc(12 - RTScounter);
  2669.     printf("'");              statprn();                  printf("'\n");
  2670.   }
  2671. }
  2672.  
  2673. SEC()
  2674. {
  2675.   int pc;
  2676.   pc = PC-1;
  2677.   C=1;
  2678.   if (trace)
  2679.   {
  2680.     if (antalarg > 2)
  2681.       botomline();
  2682.     hexprn(pc,4);             printf("-38 ");             printf("  ");
  2683.     printf("   :SEC");        printf("         ");
  2684.     prnspc(RTScounter);
  2685.     printf(";Set carry flag  1 -> C");
  2686.     prnspc(14 - RTScounter);
  2687.     printf("'");              statprn();                  printf("'\n");
  2688.   }
  2689. }
  2690.  
  2691. STAabs_x()
  2692. {
  2693.   int pc,
  2694.       codeh,
  2695.       codel,
  2696.       codel2,
  2697.       codeh2;
  2698.   pc = PC-1;
  2699.   X &= 0xFF;
  2700.   codel = loadOp();           codeh = loadOp();
  2701.   codel2 = codel+X;           codeh2 = codeh + ((codel2 >> 8) & 1);
  2702.   saveCo((codeh2 & 0xFF),(codel2 & 0xFF),(A & 0xFF));
  2703.   if (trace)
  2704.   {
  2705.     if (antalarg > 2)
  2706.       botomline();
  2707.     hexprn(pc,4);             printf("-9D ");
  2708.     hexprn(codel,2);          printf(" ");                hexprn(codeh,2);
  2709.     printf(":STA ($");        hexprn(codeh,2);            hexprn(codel,2);
  2710.     printf("),X");            prnspc(RTScounter);
  2711.     printf(";Store accumulator ");                        hexprn(A,2);
  2712.     printf(" to ");           hexprn(codeh2,2);           hexprn(codel2,2);
  2713.     prnspc(7 - RTScounter);
  2714.     printf("'");              statprn();                  printf("'\n");
  2715.   }
  2716. }
  2717.  
  2718. STAzpa()
  2719. {
  2720.   int pc,
  2721.       code,
  2722.       codel,
  2723.       codeh;
  2724.   pc = PC-1;
  2725.   code = (A & 0xFF);
  2726.   codel =loadOp();codeh = 0x00;
  2727.   saveCo(codeh,codel,code);
  2728.   if (trace)
  2729.   {
  2730.     if (antalarg > 2)
  2731.       botomline();
  2732.     hexprn(pc,4);             printf("-85 ");             hexprn(codel,2);
  2733.     printf("   :STA $");      hexprn(codel,2);            printf("     ");
  2734.     prnspc(RTScounter);
  2735.     printf(";Store accumulator ");                        hexprn(A,2);
  2736.     printf(" to $");          hexprn(codel,2);
  2737.     prnspc(9 - RTScounter);
  2738.     printf("'");              statprn();                  printf("'\n");
  2739.   }
  2740. }
  2741.  
  2742. STAind_y()
  2743. {
  2744.   int pc,
  2745.       code,
  2746.       codel,
  2747.       codeh,
  2748.       codel2,
  2749.       codeh2,
  2750.       codel3,
  2751.       codeh3;
  2752.   pc = PC-1;
  2753.   Y &= 0xFF;
  2754.   code = loadOp();
  2755.   codel = code+1;                  codeh = 0x00;
  2756.   codel &= 0xFF;
  2757.   codel2 = loadCo(0x00,code);      codeh2 = loadCo(codeh,codel);
  2758.   codel3 = codel2 + Y;             codeh3 = codeh2 + ((codel3 >>8) & 1);
  2759.   codel3 &= 0xFF;                  codeh3 &= 0xFF;
  2760.   saveCo(codeh3,codel3,(A & 0xFF));
  2761.   if (trace)
  2762.   {
  2763.     if (antalarg > 2)
  2764.       botomline();
  2765.     hexprn(pc,4);             printf("-91 ");             hexprn(code,2);
  2766.     printf("   :STA ($");     hexprn(code,2);             printf("),Y ");
  2767.     prnspc(RTScounter);
  2768.     printf(";Store A ");      hexprn(A,2);
  2769.     printf(" to ");           hexprn(codeh3,2);           hexprn(codel3,2);
  2770.     prnspc(17 - RTScounter);
  2771.     printf("'");              statprn();                  printf("'\n");
  2772.   }
  2773. }
  2774.  
  2775. STAzpa_x()
  2776. {
  2777.   int pc,
  2778.       code,
  2779.       codel,
  2780.       codeh;
  2781.   pc = PC-1;
  2782.   X &= 0xFF;
  2783.   code = loadOp();
  2784.   codel = code + X;
  2785.   codel &= 0xFF;
  2786.   saveCo(0x00,(codel & 0xFF),(A & 0xFF));
  2787.   if (trace)
  2788.   {
  2789.     if (antalarg > 2)
  2790.       botomline();
  2791.     hexprn(pc,4);             printf("-95 ");             hexprn(code,2);
  2792.     printf("   :STA $");      hexprn(0x00,2);             hexprn(code,2);
  2793.     printf(",X ");            prnspc(RTScounter);
  2794.     printf(";Store accumulator ");                        hexprn(A,2);
  2795.     printf(" to ");           hexprn(codeh,2);            hexprn(codel,2);
  2796.     prnspc(8 - RTScounter);
  2797.     printf("'");              statprn();                  printf("'\n");
  2798.   }
  2799. }
  2800.  
  2801. STXzpa()
  2802. {
  2803.   int pc,
  2804.       code;
  2805.   pc = PC-1;
  2806.   code = loadOp();
  2807.   saveCo((0x00),(code & 0xFF),(X & 0xFF));
  2808.   if (trace)
  2809.   {
  2810.     if (antalarg > 2)
  2811.       botomline();
  2812.     hexprn(pc,4);             printf("-86 ");             hexprn(code,2);
  2813.     printf("   :STX $");      hexprn(code,2);
  2814.     printf("     ");
  2815.     prnspc(RTScounter);
  2816.     printf(";Store index X ");                            hexprn(X,2);
  2817.     printf(" to ");           hexprn(0x00,2);             hexprn(code,2);
  2818.     prnspc(12 - RTScounter);
  2819.     printf("'");              statprn();                  printf("'\n");
  2820.   }
  2821. }
  2822.  
  2823. STYzpa()
  2824. {
  2825.   int pc,
  2826.       code;
  2827.   pc = PC-1;
  2828.   code = loadOp();
  2829.   saveCo((0x00),(code & 0xFF),(Y & 0xFF));
  2830.   if (trace)
  2831.   {
  2832.     if (antalarg > 2)
  2833.       botomline();
  2834.     hexprn(pc,4);             printf("-84 ");             hexprn(code,2);
  2835.     printf("   :STY $");      hexprn(code,2);
  2836.     printf("     ");
  2837.     prnspc(RTScounter);
  2838.     printf(";Store index Y ");                            hexprn(Y,2);
  2839.     printf(" to ");           hexprn(0x00,2);             hexprn(code,2);
  2840.     prnspc(12 - RTScounter);
  2841.     printf("'");              statprn();                  printf("'\n");
  2842.   }
  2843. }
  2844.  
  2845. STYzpa_x()
  2846. {
  2847.   int pc,
  2848.       code,
  2849.       codel,
  2850.       codeh;
  2851.   pc = PC-1;
  2852.   X &= 0xFF;
  2853.   code = loadOp();         codeh = 0x00;
  2854.   codel = code + X;
  2855.   codel &= 0xFF;
  2856.   saveCo(codeh,codel,(Y & 0xFF));
  2857.   if (trace)
  2858.   {
  2859.     if (antalarg > 2)
  2860.       botomline();
  2861.     hexprn(pc,4);             printf("-94 ");             hexprn(code,2);
  2862.     printf("   :STY $");      hexprn(0x00,2);             hexprn(code,2);
  2863.     printf(",X ");            prnspc(RTScounter);
  2864.     printf(";Store accumulator ");                        hexprn(Y,2);
  2865.     printf(" to ");           hexprn(codeh,2);            hexprn(codel,2);
  2866.     prnspc(8 - RTScounter);
  2867.     printf("'");              statprn();                  printf("'\n");
  2868.   }
  2869. }
  2870.  
  2871. TXA()
  2872. {
  2873.   int pc;
  2874.   pc = PC-1;
  2875.   A = X;
  2876.   N = ((A & 0xFF) >> 7);
  2877.   Z =  (A & 0xFF) == 0;
  2878.   if (trace)
  2879.   {
  2880.     if (antalarg > 2)
  2881.       botomline();
  2882.     hexprn(pc,4);             printf("-8A ");             printf("  ");
  2883.     printf("   :TXA");        printf("         ");
  2884.     prnspc(RTScounter);
  2885.     printf(";Transfer index X ");                         hexprn(A,2);
  2886.     printf(" to A");
  2887.     prnspc(12 - RTScounter);
  2888.     printf("'");              statprn();                  printf("'\n");
  2889.   }
  2890. }
  2891.  
  2892. TAX()
  2893. {
  2894.   int pc;
  2895.   pc = PC-1;
  2896.   X = A;
  2897.   N = ((A & 0xFF) >> 7);
  2898.   Z =  (A & 0xFF) == 0;
  2899.   if (trace)
  2900.   {
  2901.     if (antalarg > 2)
  2902.       botomline();
  2903.     hexprn(pc,4);             printf("-AA ");             printf("  ");
  2904.     printf("   :TAX");        printf("         ");
  2905.     prnspc(RTScounter);
  2906.     printf(";Transfer Accumulator ");                     hexprn(A,2);
  2907.     printf(" to X");
  2908.     prnspc(8 - RTScounter);
  2909.     printf("'");              statprn();                  printf("'\n");
  2910.   }
  2911. }
  2912.  
  2913. TAY()
  2914. {
  2915.   int pc;
  2916.   pc = PC-1;
  2917.   Y = A;
  2918.   N = ((A & 0xFF) >> 7);
  2919.   Z =  (A & 0xFF) == 0;
  2920.   if (trace)
  2921.   {
  2922.     if (antalarg > 2)
  2923.       botomline();
  2924.     hexprn(pc,4);             printf("-A8 ");             printf("  ");
  2925.     printf("   :TAY");        printf("         ");
  2926.     prnspc(RTScounter);
  2927.     printf(";Transfer Accumulator ");                     hexprn(A,2);
  2928.     printf(" to Y");
  2929.     prnspc(8 - RTScounter);
  2930.     printf("'");              statprn();                  printf("'\n");
  2931.   }
  2932. }
  2933.  
  2934. TSX()
  2935. {
  2936.   int pc;
  2937.   pc = PC-1;
  2938.   X = S;
  2939.   N = ((A & 0xFF) >> 7);
  2940.   Z =  (A & 0xFF) == 0;
  2941.   if (trace)
  2942.   {
  2943.     if (antalarg > 2)
  2944.       botomline();
  2945.     hexprn(pc,4);             printf("-BA ");             printf("  ");
  2946.     printf("   :TSX");        printf("         ");
  2947.     prnspc(RTScounter);
  2948.     printf(";Transfer stack point ");                     hexprn(S,2);
  2949.     printf(" to X");
  2950.     prnspc(8 - RTScounter);
  2951.     printf("'");              statprn();                  printf("'\n");
  2952.   }
  2953. }
  2954.  
  2955. TYA()
  2956. {
  2957.   int pc;
  2958.   pc = PC-1;
  2959.   A = Y;
  2960.   N = ((A & 0xFF) >> 7);
  2961.   Z =  (A & 0xFF) == 0;
  2962.   if (trace)
  2963.   {
  2964.     if (antalarg > 2)
  2965.       botomline();
  2966.     hexprn(pc,4);             printf("-98 ");             printf("  ");
  2967.     printf("   :TYA");        printf("         ");
  2968.     prnspc(RTScounter);
  2969.     printf(";Transfer index Y ");                     hexprn(Y,2);
  2970.     printf(" to A");
  2971.     prnspc(12 - RTScounter);
  2972.     printf("'");              statprn();                  printf("'\n");
  2973.   }
  2974. }
  2975.  
  2976. int loadOp()
  2977. {
  2978.   int code;
  2979.   code=MEMORY [PC];
  2980.   PC++;
  2981.   return (code);
  2982. }
  2983.  
  2984. int loadCo(codeh,codel)
  2985. int codeh,
  2986.     codel;
  2987. {
  2988.   int code;
  2989.   memorymap(codeh,codel,1); /*,1);  -> read mod */
  2990.   code=MEMORY [((codeh & 0xFF) << 8) + codel];
  2991.   return (code);
  2992. }
  2993.  
  2994. saveCo(codeh,codel,code)
  2995. int codeh,
  2996.     codel,
  2997.     code;
  2998. {
  2999.   MEMORY[(codeh<<8)+codel] = code;
  3000.   memorymap(codeh,codel,0); /*,0);  -> write mod */
  3001. }
  3002.  
  3003. pushS(code)
  3004. int code;
  3005. {
  3006.   MEMORY[0x100+S] = code;
  3007.   S--;
  3008. }
  3009.  
  3010. int pullS()
  3011. {
  3012.   int code;
  3013.   S++;
  3014.   code = MEMORY[0x100+S];
  3015.   return (code);
  3016. }
  3017.  
  3018. int statprn()
  3019. {
  3020.   if (N)
  3021.     printf("Mi");
  3022.   else
  3023.     printf("Pl");
  3024.   if (V)
  3025.     printf("Ov");
  3026.   else
  3027.     printf("Nv");
  3028.   if (B)
  3029.     printf("Br");
  3030.   else
  3031.     printf("Nb");
  3032.   if (D)
  3033.     printf("Dm");
  3034.   else
  3035.     printf("Nd");
  3036.   if (I)
  3037.     printf("Id");
  3038.   else
  3039.     printf("Ie");
  3040.   if (Z)
  3041.     printf("Ze");
  3042.   else
  3043.     printf("Nz");
  3044.   if (C)
  3045.     printf("Ca");
  3046.   else
  3047.     printf("Nc");
  3048. }
  3049.  
  3050. int memorymap(codeh,codel,r_w)
  3051. int codeh,
  3052.     codel,
  3053.     r_w;
  3054. {
  3055.   int address;
  3056.   address = (((codeh & 0xFF)<<8) | (codel & 0xFF));
  3057.  
  3058.   if ((address >= 0x0400) && (address <= 0x7FF))
  3059.   {
  3060.     int radflg;
  3061.     if (radflg = video_check(address) )
  3062.     {
  3063.       if (!r_w)
  3064.         video_out(address,radflg);
  3065.     }
  3066.     else
  3067.     {
  3068.       /* slotdefine i/o */
  3069.     }
  3070.   }
  3071.  
  3072.   if ((address & 0xFFFF) == 0xC000)
  3073.   {
  3074.     int slask;
  3075.     if (r_w)
  3076.     {
  3077.       slask = inkey(MEMORY [address]);
  3078.       if ((slask & 0x7F) > 0x5F)
  3079.         slask -= 0x20;
  3080.       MEMORY [address] = slask;
  3081.     }
  3082.   }
  3083.  
  3084.   if ((address & 0xFFFF) == 0xC010)
  3085.   {
  3086.     int slask;
  3087.     if (r_w)
  3088.       slask = MEMORY [0xC000] & 0x7F;
  3089.       MEMORY [0xC000] = slask;
  3090.   }
  3091.  
  3092.   if ((address & 0xFFFF) == 0xC030)
  3093.   {
  3094.     soundcounter = soundcounter +1;
  3095.     if (soundcounter > 120)
  3096.     {
  3097.       printf("\007");
  3098.       soundcounter = 0;
  3099.     }
  3100.   }
  3101. }
  3102.  
  3103. main(antal,params)
  3104. int antal;
  3105. char *params[];
  3106. {
  3107.  
  3108. short int slask;
  3109.       int loop,
  3110.           code;
  3111.  
  3112. antalarg = antal;
  3113.  
  3114. if (antal > 1)
  3115. {
  3116.   sscanf(params[1],"%lx",&brkpoint);
  3117. }
  3118.  
  3119.   /* * * * START of PROGRAM * * * */
  3120.  
  3121. halfdup();
  3122.  
  3123. for (loop=0x000;loop<0x7ff+1;loop++)
  3124.   MEMORY[(loop+0xf800)]=MEMORY$F8[loop];
  3125.  
  3126. for (loop=0x0400;loop<0x07FF+1;loop++)
  3127.   MEMORY[ loop ] = 0xA0;
  3128.  
  3129. for (loop=0x00;loop<0x10+1;loop++)
  3130.   MEMORY[ 0x300+loop ] = PROGRAM [ loop ];
  3131.  
  3132.  
  3133.  
  3134.  
  3135.  
  3136.   C=0;Z=0;I=0;D=0;B=0;V=0;N=0;    /* init of status_registr  */
  3137.   PCL=MEMORY[0xFFFC];             /* init program_counter    */
  3138.   PCH=MEMORY[0xFFFD];
  3139.   S =0xff;                        /* init stack pointer      */
  3140.  
  3141. printf("\033[1;1f");
  3142. printf("\033[2JINIT$           APPLE ][\033[1;1f");
  3143.  
  3144. cycle:
  3145.  
  3146.     CPU(code=loadOp());
  3147.  
  3148.   if (trace)
  3149.   {
  3150.     t1in(slask);
  3151.     if ((slask == 't') | (slask == 'T'))
  3152.     {
  3153.       tracepoint = RTScounter;
  3154.       troff =1;
  3155.       trace =0;
  3156.     }
  3157.   }
  3158.  
  3159.   if (brkpoint == PC)
  3160.   {
  3161.     trace =1;
  3162.     if (antalarg == 2)
  3163.       printf("\n");
  3164.   }
  3165.  
  3166.   if (!((B == 1) && (I == 0)))
  3167.     goto cycle;
  3168.  
  3169.   printf("\n");
  3170.   RTI();
  3171.   printf(" PC=");  hexprn(PC,4);
  3172.   printf(" A=");    hexprn(A,2);
  3173.   printf(" X=");    hexprn(X,2);
  3174.   printf(" Y=");    hexprn(Y,2);
  3175.   printf(" P=");    binprn(P,7);
  3176.   printf(" S=");    hexprn(S,2);
  3177.   printf("  code $%x\n\n",code);
  3178.  
  3179.   fulldup();
  3180. }
  3181.