home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / emulator / unix / z80pack / z80sim / sim2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-10  |  50.8 KB  |  2,952 lines
  1. /*
  2.  * Z80SIM  -  a    Z80-CPU    simulator
  3.  *
  4.  * Copyright (C) 1987-92 by Udo Munk
  5.  *
  6.  * This module of the Z80-CPU simulator must not be modified by a user,
  7.  * see license agreement!
  8.  *
  9.  * History:
  10.  * 28-SEP-87 Development on TARGON/35 with AT&T Unix System V.3
  11.  * 11-JAN-89 Release 1.1
  12.  * 08-FEB-89 Release 1.2
  13.  * 13-MAR-89 Release 1.3
  14.  * 09-FEB-90 Release 1.4 Ported to TARGON/31 M10/30
  15.  * 20-DEC-90 Release 1.5 Ported to COHERENT 3.0
  16.  * 10-JUN-92 Release 1.6 long casting problem solved with COHERENT 3.2
  17.  *             and some optimization
  18.  * 25-JUN-92 Release 1.7 comments in english
  19.  */
  20.  
  21. /*
  22.  *    Like the function "cpu()" this one emulates multi byte opcodes
  23.  *    starting with 0xcb
  24.  */
  25.  
  26. #include "sim.h"
  27. #include "simglb.h"
  28.  
  29. long op_cb_handel()
  30. {
  31.     long trap_cb();
  32.     long op_srla(),    op_srlb(), op_srlc(), op_srld(), op_srle();
  33.     long op_srlh(),    op_srll(), op_srlhl();
  34.     long op_slaa(),    op_slab(), op_slac(), op_slad(), op_slae();
  35.     long op_slah(),    op_slal(), op_slahl();
  36.     long op_rlra(),    op_rlb(), op_rlc(), op_rld(), op_rle();
  37.     long op_rlh(), op_rll(), op_rlhl();
  38.     long op_rrra(),    op_rrb(), op_rrc(), op_rrd(), op_rre();
  39.     long op_rrh(), op_rrl(), op_rrhl();
  40.     long op_rrcra(), op_rrcb(), op_rrcc(), op_rrcd(), op_rrce();
  41.     long op_rrch(),    op_rrcl(), op_rrchl();
  42.     long op_rlcra(), op_rlcb(), op_rlcc(), op_rlcd(), op_rlce();
  43.     long op_rlch(),    op_rlcl(), op_rlchl();
  44.     long op_sraa(),    op_srab(), op_srac(), op_srad(), op_srae();
  45.     long op_srah(),    op_sral(), op_srahl();
  46.     long op_sb0a(),    op_sb1a(), op_sb2a(), op_sb3a();
  47.     long op_sb4a(),    op_sb5a(), op_sb6a(), op_sb7a();
  48.     long op_sb0b(),    op_sb1b(), op_sb2b(), op_sb3b();
  49.     long op_sb4b(),    op_sb5b(), op_sb6b(), op_sb7b();
  50.     long op_sb0c(),    op_sb1c(), op_sb2c(), op_sb3c();
  51.     long op_sb4c(),    op_sb5c(), op_sb6c(), op_sb7c();
  52.     long op_sb0d(),    op_sb1d(), op_sb2d(), op_sb3d();
  53.     long op_sb4d(),    op_sb5d(), op_sb6d(), op_sb7d();
  54.     long op_sb0e(),    op_sb1e(), op_sb2e(), op_sb3e();
  55.     long op_sb4e(),    op_sb5e(), op_sb6e(), op_sb7e();
  56.     long op_sb0h(),    op_sb1h(), op_sb2h(), op_sb3h();
  57.     long op_sb4h(),    op_sb5h(), op_sb6h(), op_sb7h();
  58.     long op_sb0l(),    op_sb1l(), op_sb2l(), op_sb3l();
  59.     long op_sb4l(),    op_sb5l(), op_sb6l(), op_sb7l();
  60.     long op_sb0hl(), op_sb1hl(), op_sb2hl(), op_sb3hl();
  61.     long op_sb4hl(), op_sb5hl(), op_sb6hl(), op_sb7hl();
  62.     long op_rb0a(),    op_rb1a(), op_rb2a(), op_rb3a();
  63.     long op_rb4a(),    op_rb5a(), op_rb6a(), op_rb7a();
  64.     long op_rb0b(),    op_rb1b(), op_rb2b(), op_rb3b();
  65.     long op_rb4b(),    op_rb5b(), op_rb6b(), op_rb7b();
  66.     long op_rb0c(),    op_rb1c(), op_rb2c(), op_rb3c();
  67.     long op_rb4c(),    op_rb5c(), op_rb6c(), op_rb7c();
  68.     long op_rb0d(),    op_rb1d(), op_rb2d(), op_rb3d();
  69.     long op_rb4d(),    op_rb5d(), op_rb6d(), op_rb7d();
  70.     long op_rb0e(),    op_rb1e(), op_rb2e(), op_rb3e();
  71.     long op_rb4e(),    op_rb5e(), op_rb6e(), op_rb7e();
  72.     long op_rb0h(),    op_rb1h(), op_rb2h(), op_rb3h();
  73.     long op_rb4h(),    op_rb5h(), op_rb6h(), op_rb7h();
  74.     long op_rb0l(),    op_rb1l(), op_rb2l(), op_rb3l();
  75.     long op_rb4l(),    op_rb5l(), op_rb6l(), op_rb7l();
  76.     long op_rb0hl(), op_rb1hl(), op_rb2hl(), op_rb3hl();
  77.     long op_rb4hl(), op_rb5hl(), op_rb6hl(), op_rb7hl();
  78.     long op_tb0a(),    op_tb1a(), op_tb2a(), op_tb3a();
  79.     long op_tb4a(),    op_tb5a(), op_tb6a(), op_tb7a();
  80.     long op_tb0b(),    op_tb1b(), op_tb2b(), op_tb3b();
  81.     long op_tb4b(),    op_tb5b(), op_tb6b(), op_tb7b();
  82.     long op_tb0c(),    op_tb1c(), op_tb2c(), op_tb3c();
  83.     long op_tb4c(),    op_tb5c(), op_tb6c(), op_tb7c();
  84.     long op_tb0d(),    op_tb1d(), op_tb2d(), op_tb3d();
  85.     long op_tb4d(),    op_tb5d(), op_tb6d(), op_tb7d();
  86.     long op_tb0e(),    op_tb1e(), op_tb2e(), op_tb3e();
  87.     long op_tb4e(),    op_tb5e(), op_tb6e(), op_tb7e();
  88.     long op_tb0h(),    op_tb1h(), op_tb2h(), op_tb3h();
  89.     long op_tb4h(),    op_tb5h(), op_tb6h(), op_tb7h();
  90.     long op_tb0l(),    op_tb1l(), op_tb2l(), op_tb3l();
  91.     long op_tb4l(),    op_tb5l(), op_tb6l(), op_tb7l();
  92.     long op_tb0hl(), op_tb1hl(), op_tb2hl(), op_tb3hl();
  93.     long op_tb4hl(), op_tb5hl(), op_tb6hl(), op_tb7hl();
  94.  
  95.     static long (*op_cb[256]) () = {
  96.         op_rlcb,            /* 0x00    */
  97.         op_rlcc,            /* 0x01    */
  98.         op_rlcd,            /* 0x02    */
  99.         op_rlce,            /* 0x03    */
  100.         op_rlch,            /* 0x04    */
  101.         op_rlcl,            /* 0x05    */
  102.         op_rlchl,            /* 0x06    */
  103.         op_rlcra,            /* 0x07    */
  104.         op_rrcb,            /* 0x08    */
  105.         op_rrcc,            /* 0x09    */
  106.         op_rrcd,            /* 0x0a    */
  107.         op_rrce,            /* 0x0b    */
  108.         op_rrch,            /* 0x0c    */
  109.         op_rrcl,            /* 0x0d    */
  110.         op_rrchl,            /* 0x0e    */
  111.         op_rrcra,            /* 0x0f    */
  112.         op_rlb,                /* 0x10    */
  113.         op_rlc,                /* 0x11    */
  114.         op_rld,                /* 0x12    */
  115.         op_rle,                /* 0x13    */
  116.         op_rlh,                /* 0x14    */
  117.         op_rll,                /* 0x15    */
  118.         op_rlhl,            /* 0x16    */
  119.         op_rlra,            /* 0x17    */
  120.         op_rrb,                /* 0x18    */
  121.         op_rrc,                /* 0x19    */
  122.         op_rrd,                /* 0x1a    */
  123.         op_rre,                /* 0x1b    */
  124.         op_rrh,                /* 0x1c    */
  125.         op_rrl,                /* 0x1d    */
  126.         op_rrhl,            /* 0x1e    */
  127.         op_rrra,            /* 0x1f    */
  128.         op_slab,            /* 0x20    */
  129.         op_slac,            /* 0x21    */
  130.         op_slad,            /* 0x22    */
  131.         op_slae,            /* 0x23    */
  132.         op_slah,            /* 0x24    */
  133.         op_slal,            /* 0x25    */
  134.         op_slahl,            /* 0x26    */
  135.         op_slaa,            /* 0x27    */
  136.         op_srab,            /* 0x28    */
  137.         op_srac,            /* 0x29    */
  138.         op_srad,            /* 0x2a    */
  139.         op_srae,            /* 0x2b    */
  140.         op_srah,            /* 0x2c    */
  141.         op_sral,            /* 0x2d    */
  142.         op_srahl,            /* 0x2e    */
  143.         op_sraa,            /* 0x2f    */
  144.         trap_cb,            /* 0x30    */
  145.         trap_cb,            /* 0x31    */
  146.         trap_cb,            /* 0x32    */
  147.         trap_cb,            /* 0x33    */
  148.         trap_cb,            /* 0x34    */
  149.         trap_cb,            /* 0x35    */
  150.         trap_cb,            /* 0x36    */
  151.         trap_cb,            /* 0x37    */
  152.         op_srlb,            /* 0x38    */
  153.         op_srlc,            /* 0x39    */
  154.         op_srld,            /* 0x3a    */
  155.         op_srle,            /* 0x3b    */
  156.         op_srlh,            /* 0x3c    */
  157.         op_srll,            /* 0x3d    */
  158.         op_srlhl,            /* 0x3e    */
  159.         op_srla,            /* 0x3f    */
  160.         op_tb0b,            /* 0x40    */
  161.         op_tb0c,            /* 0x41    */
  162.         op_tb0d,            /* 0x42    */
  163.         op_tb0e,            /* 0x43    */
  164.         op_tb0h,            /* 0x44    */
  165.         op_tb0l,            /* 0x45    */
  166.         op_tb0hl,            /* 0x46    */
  167.         op_tb0a,            /* 0x47    */
  168.         op_tb1b,            /* 0x48    */
  169.         op_tb1c,            /* 0x49    */
  170.         op_tb1d,            /* 0x4a    */
  171.         op_tb1e,            /* 0x4b    */
  172.         op_tb1h,            /* 0x4c    */
  173.         op_tb1l,            /* 0x4d    */
  174.         op_tb1hl,            /* 0x4e    */
  175.         op_tb1a,            /* 0x4f    */
  176.         op_tb2b,            /* 0x50    */
  177.         op_tb2c,            /* 0x51    */
  178.         op_tb2d,            /* 0x52    */
  179.         op_tb2e,            /* 0x53    */
  180.         op_tb2h,            /* 0x54    */
  181.         op_tb2l,            /* 0x55    */
  182.         op_tb2hl,            /* 0x56    */
  183.         op_tb2a,            /* 0x57    */
  184.         op_tb3b,            /* 0x58    */
  185.         op_tb3c,            /* 0x59    */
  186.         op_tb3d,            /* 0x5a    */
  187.         op_tb3e,            /* 0x5b    */
  188.         op_tb3h,            /* 0x5c    */
  189.         op_tb3l,            /* 0x5d    */
  190.         op_tb3hl,            /* 0x5e    */
  191.         op_tb3a,            /* 0x5f    */
  192.         op_tb4b,            /* 0x60    */
  193.         op_tb4c,            /* 0x61    */
  194.         op_tb4d,            /* 0x62    */
  195.         op_tb4e,            /* 0x63    */
  196.         op_tb4h,            /* 0x64    */
  197.         op_tb4l,            /* 0x65    */
  198.         op_tb4hl,            /* 0x66    */
  199.         op_tb4a,            /* 0x67    */
  200.         op_tb5b,            /* 0x68    */
  201.         op_tb5c,            /* 0x69    */
  202.         op_tb5d,            /* 0x6a    */
  203.         op_tb5e,            /* 0x6b    */
  204.         op_tb5h,            /* 0x6c    */
  205.         op_tb5l,            /* 0x6d    */
  206.         op_tb5hl,            /* 0x6e    */
  207.         op_tb5a,            /* 0x6f    */
  208.         op_tb6b,            /* 0x70    */
  209.         op_tb6c,            /* 0x71    */
  210.         op_tb6d,            /* 0x72    */
  211.         op_tb6e,            /* 0x73    */
  212.         op_tb6h,            /* 0x74    */
  213.         op_tb6l,            /* 0x75    */
  214.         op_tb6hl,            /* 0x76    */
  215.         op_tb6a,            /* 0x77    */
  216.         op_tb7b,            /* 0x78    */
  217.         op_tb7c,            /* 0x79    */
  218.         op_tb7d,            /* 0x7a    */
  219.         op_tb7e,            /* 0x7b    */
  220.         op_tb7h,            /* 0x7c    */
  221.         op_tb7l,            /* 0x7d    */
  222.         op_tb7hl,            /* 0x7e    */
  223.         op_tb7a,            /* 0x7f    */
  224.         op_rb0b,            /* 0x80    */
  225.         op_rb0c,            /* 0x81    */
  226.         op_rb0d,            /* 0x82    */
  227.         op_rb0e,            /* 0x83    */
  228.         op_rb0h,            /* 0x84    */
  229.         op_rb0l,            /* 0x85    */
  230.         op_rb0hl,            /* 0x86    */
  231.         op_rb0a,            /* 0x87    */
  232.         op_rb1b,            /* 0x88    */
  233.         op_rb1c,            /* 0x89    */
  234.         op_rb1d,            /* 0x8a    */
  235.         op_rb1e,            /* 0x8b    */
  236.         op_rb1h,            /* 0x8c    */
  237.         op_rb1l,            /* 0x8d    */
  238.         op_rb1hl,            /* 0x8e    */
  239.         op_rb1a,            /* 0x8f    */
  240.         op_rb2b,            /* 0x90    */
  241.         op_rb2c,            /* 0x91    */
  242.         op_rb2d,            /* 0x92    */
  243.         op_rb2e,            /* 0x93    */
  244.         op_rb2h,            /* 0x94    */
  245.         op_rb2l,            /* 0x95    */
  246.         op_rb2hl,            /* 0x96    */
  247.         op_rb2a,            /* 0x97    */
  248.         op_rb3b,            /* 0x98    */
  249.         op_rb3c,            /* 0x99    */
  250.         op_rb3d,            /* 0x9a    */
  251.         op_rb3e,            /* 0x9b    */
  252.         op_rb3h,            /* 0x9c    */
  253.         op_rb3l,            /* 0x9d    */
  254.         op_rb3hl,            /* 0x9e    */
  255.         op_rb3a,            /* 0x9f    */
  256.         op_rb4b,            /* 0xa0    */
  257.         op_rb4c,            /* 0xa1    */
  258.         op_rb4d,            /* 0xa2    */
  259.         op_rb4e,            /* 0xa3    */
  260.         op_rb4h,            /* 0xa4    */
  261.         op_rb4l,            /* 0xa5    */
  262.         op_rb4hl,            /* 0xa6    */
  263.         op_rb4a,            /* 0xa7    */
  264.         op_rb5b,            /* 0xa8    */
  265.         op_rb5c,            /* 0xa9    */
  266.         op_rb5d,            /* 0xaa    */
  267.         op_rb5e,            /* 0xab    */
  268.         op_rb5h,            /* 0xac    */
  269.         op_rb5l,            /* 0xad    */
  270.         op_rb5hl,            /* 0xae    */
  271.         op_rb5a,            /* 0xaf    */
  272.         op_rb6b,            /* 0xb0    */
  273.         op_rb6c,            /* 0xb1    */
  274.         op_rb6d,            /* 0xb2    */
  275.         op_rb6e,            /* 0xb3    */
  276.         op_rb6h,            /* 0xb4    */
  277.         op_rb6l,            /* 0xb5    */
  278.         op_rb6hl,            /* 0xb6    */
  279.         op_rb6a,            /* 0xb7    */
  280.         op_rb7b,            /* 0xb8    */
  281.         op_rb7c,            /* 0xb9    */
  282.         op_rb7d,            /* 0xba    */
  283.         op_rb7e,            /* 0xbb    */
  284.         op_rb7h,            /* 0xbc    */
  285.         op_rb7l,            /* 0xbd    */
  286.         op_rb7hl,            /* 0xbe    */
  287.         op_rb7a,            /* 0xbf    */
  288.         op_sb0b,            /* 0xc0    */
  289.         op_sb0c,            /* 0xc1    */
  290.         op_sb0d,            /* 0xc2    */
  291.         op_sb0e,            /* 0xc3    */
  292.         op_sb0h,            /* 0xc4    */
  293.         op_sb0l,            /* 0xc5    */
  294.         op_sb0hl,            /* 0xc6    */
  295.         op_sb0a,            /* 0xc7    */
  296.         op_sb1b,            /* 0xc8    */
  297.         op_sb1c,            /* 0xc9    */
  298.         op_sb1d,            /* 0xca    */
  299.         op_sb1e,            /* 0xcb    */
  300.         op_sb1h,            /* 0xcc    */
  301.         op_sb1l,            /* 0xcd    */
  302.         op_sb1hl,            /* 0xce    */
  303.         op_sb1a,            /* 0xcf    */
  304.         op_sb2b,            /* 0xd0    */
  305.         op_sb2c,            /* 0xd1    */
  306.         op_sb2d,            /* 0xd2    */
  307.         op_sb2e,            /* 0xd3    */
  308.         op_sb2h,            /* 0xd4    */
  309.         op_sb2l,            /* 0xd5    */
  310.         op_sb2hl,            /* 0xd6    */
  311.         op_sb2a,            /* 0xd7    */
  312.         op_sb3b,            /* 0xd8    */
  313.         op_sb3c,            /* 0xd9    */
  314.         op_sb3d,            /* 0xda    */
  315.         op_sb3e,            /* 0xdb    */
  316.         op_sb3h,            /* 0xdc    */
  317.         op_sb3l,            /* 0xdd    */
  318.         op_sb3hl,            /* 0xde    */
  319.         op_sb3a,            /* 0xdf    */
  320.         op_sb4b,            /* 0xe0    */
  321.         op_sb4c,            /* 0xe1    */
  322.         op_sb4d,            /* 0xe2    */
  323.         op_sb4e,            /* 0xe3    */
  324.         op_sb4h,            /* 0xe4    */
  325.         op_sb4l,            /* 0xe5    */
  326.         op_sb4hl,            /* 0xe6    */
  327.         op_sb4a,            /* 0xe7    */
  328.         op_sb5b,            /* 0xe8    */
  329.         op_sb5c,            /* 0xe9    */
  330.         op_sb5d,            /* 0xea    */
  331.         op_sb5e,            /* 0xeb    */
  332.         op_sb5h,            /* 0xec    */
  333.         op_sb5l,            /* 0xed    */
  334.         op_sb5hl,            /* 0xee    */
  335.         op_sb5a,            /* 0xef    */
  336.         op_sb6b,            /* 0xf0    */
  337.         op_sb6c,            /* 0xf1    */
  338.         op_sb6d,            /* 0xf2    */
  339.         op_sb6e,            /* 0xf3    */
  340.         op_sb6h,            /* 0xf4    */
  341.         op_sb6l,            /* 0xf5    */
  342.         op_sb6hl,            /* 0xf6    */
  343.         op_sb6a,            /* 0xf7    */
  344.         op_sb7b,            /* 0xf8    */
  345.         op_sb7c,            /* 0xf9    */
  346.         op_sb7d,            /* 0xfa    */
  347.         op_sb7e,            /* 0xfb    */
  348.         op_sb7h,            /* 0xfc    */
  349.         op_sb7l,            /* 0xfd    */
  350.         op_sb7hl,            /* 0xfe    */
  351.         op_sb7a                /* 0xff    */
  352.     };
  353.  
  354. #ifdef WANT_TIM
  355.     register long t;
  356.     t = (*op_cb[*PC++]) ();        /* execute next opcode */
  357. #else
  358.     (*op_cb[*PC++]) ();
  359. #endif
  360.  
  361. #ifdef WANT_PCC
  362.         if (PC > ram + 65535)    /* correct PC overrun */
  363.             PC = ram;
  364. #endif
  365.  
  366. #ifdef WANT_TIM
  367.     return(t);
  368. #endif
  369. }
  370.  
  371. /*
  372.  *    This function traps all illegal opcodes following the
  373.  *    initial 0xcb of a multi byte opcode.
  374.  */
  375. static long trap_cb()
  376. {
  377.     cpu_error = OPTRAP2;
  378.     cpu_state = STOPPED;
  379. #ifdef WANT_TIM
  380.     return(0L);
  381. #endif
  382. }
  383.  
  384. static long op_srla()             /*    SRL A */
  385. {
  386.     (A & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  387.     A >>= 1;
  388.     F &= ~(H_FLAG |    N_FLAG);
  389.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  390.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  391.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  392. #ifdef WANT_TIM
  393.     return(8L);
  394. #endif
  395. }
  396.  
  397. static long op_srlb()             /*    SRL B */
  398. {
  399.     (B & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  400.     B >>= 1;
  401.     F &= ~(H_FLAG |    N_FLAG);
  402.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  403.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  404.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  405. #ifdef WANT_TIM
  406.     return(8L);
  407. #endif
  408. }
  409.  
  410. static long op_srlc()             /*    SRL C */
  411. {
  412.     (C & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  413.     C >>= 1;
  414.     F &= ~(H_FLAG |    N_FLAG);
  415.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  416.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  417.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  418. #ifdef WANT_TIM
  419.     return(8L);
  420. #endif
  421. }
  422.  
  423. static long op_srld()             /*    SRL D */
  424. {
  425.     (D & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  426.     D >>= 1;
  427.     F &= ~(H_FLAG |    N_FLAG);
  428.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  429.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  430.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  431. #ifdef WANT_TIM
  432.     return(8L);
  433. #endif
  434. }
  435.  
  436. static long op_srle()             /*    SRL E */
  437. {
  438.     (E & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  439.     E >>= 1;
  440.     F &= ~(H_FLAG |    N_FLAG);
  441.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  442.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  443.     (parrity[E]) ? (F &= ~P_FLAG) :(F |= P_FLAG);
  444. #ifdef WANT_TIM
  445.     return(8L);
  446. #endif
  447. }
  448.  
  449. static long op_srlh()             /*    SRL H */
  450. {
  451.     (H & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  452.     H >>= 1;
  453.     F &= ~(H_FLAG |    N_FLAG);
  454.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  455.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  456.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  457. #ifdef WANT_TIM
  458.     return(8L);
  459. #endif
  460. }
  461.  
  462. static long op_srll()             /*    SRL L */
  463. {
  464.     (L & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  465.     L >>= 1;
  466.     F &= ~(H_FLAG |    N_FLAG);
  467.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  468.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  469.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  470. #ifdef WANT_TIM
  471.     return(8L);
  472. #endif
  473. }
  474.  
  475. static long op_srlhl()             /*    SRL (HL) */
  476. {
  477.     register BYTE *p;
  478.  
  479.     p = ram    + (H <<    8) + L;
  480.     (*p & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  481.     *p >>= 1;
  482.     F &= ~(H_FLAG |    N_FLAG);
  483.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  484.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  485.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  486. #ifdef WANT_TIM
  487.     return(15L);
  488. #endif
  489. }
  490.  
  491. static long op_slaa()             /*    SLA A */
  492. {
  493.     (A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  494.     A <<= 1;
  495.     F &= ~(H_FLAG |    N_FLAG);
  496.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  497.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  498.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  499. #ifdef WANT_TIM
  500.     return(8L);
  501. #endif
  502. }
  503.  
  504. static long op_slab()             /*    SLA B */
  505. {
  506.     (B & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  507.     B <<= 1;
  508.     F &= ~(H_FLAG |    N_FLAG);
  509.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  510.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  511.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  512. #ifdef WANT_TIM
  513.     return(8L);
  514. #endif
  515. }
  516.  
  517. static long op_slac()             /*    SLA C */
  518. {
  519.     (C & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  520.     C <<= 1;
  521.     F &= ~(H_FLAG |    N_FLAG);
  522.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  523.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  524.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  525. #ifdef WANT_TIM
  526.     return(8L);
  527. #endif
  528. }
  529.  
  530. static long op_slad()             /*    SLA D */
  531. {
  532.     (D & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  533.     D <<= 1;
  534.     F &= ~(H_FLAG |    N_FLAG);
  535.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  536.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  537.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  538. #ifdef WANT_TIM
  539.     return(8L);
  540. #endif
  541. }
  542.  
  543. static long op_slae()             /*    SLA E */
  544. {
  545.     (E & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  546.     E <<= 1;
  547.     F &= ~(H_FLAG |    N_FLAG);
  548.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  549.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  550.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  551. #ifdef WANT_TIM
  552.     return(8L);
  553. #endif
  554. }
  555.  
  556. static long op_slah()             /*    SLA H */
  557. {
  558.     (H & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  559.     H <<= 1;
  560.     F &= ~(H_FLAG |    N_FLAG);
  561.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  562.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  563.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  564. #ifdef WANT_TIM
  565.     return(8L);
  566. #endif
  567. }
  568.  
  569. static long op_slal()             /*    SLA L */
  570. {
  571.     (L & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  572.     L <<= 1;
  573.     F &= ~(H_FLAG |    N_FLAG);
  574.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  575.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  576.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  577. #ifdef WANT_TIM
  578.     return(8L);
  579. #endif
  580. }
  581.  
  582. static long op_slahl()             /*    SLA (HL) */
  583. {
  584.     register BYTE *p;
  585.  
  586.     p = ram    + (H <<    8) + L;
  587.     (*p & 128) ? (F    |= C_FLAG) : (F    &= ~C_FLAG);
  588.     *p <<= 1;
  589.     F &= ~(H_FLAG |    N_FLAG);
  590.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  591.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  592.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  593. #ifdef WANT_TIM
  594.     return(15L);
  595. #endif
  596. }
  597.  
  598. static long op_rlra()             /*    RL A */
  599. {
  600.     register int old_c_flag;
  601.  
  602.     old_c_flag = F & C_FLAG;
  603.     (A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  604.     A <<= 1;
  605.     if (old_c_flag)    A |= 1;
  606.     F &= ~(H_FLAG |    N_FLAG);
  607.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  608.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  609.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  610. #ifdef WANT_TIM
  611.     return(8L);
  612. #endif
  613. }
  614.  
  615. static long op_rlb()             /*    RL B */
  616. {
  617.     register int old_c_flag;
  618.  
  619.     old_c_flag = F & C_FLAG;
  620.     (B & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  621.     B <<= 1;
  622.     if (old_c_flag)    B |= 1;
  623.     F &= ~(H_FLAG |    N_FLAG);
  624.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  625.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  626.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  627. #ifdef WANT_TIM
  628.     return(8L);
  629. #endif
  630. }
  631.  
  632. static long op_rlc()             /*    RL C */
  633. {
  634.     register int old_c_flag;
  635.  
  636.     old_c_flag = F & C_FLAG;
  637.     (C & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  638.     C <<= 1;
  639.     if (old_c_flag)    C |= 1;
  640.     F &= ~(H_FLAG |    N_FLAG);
  641.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  642.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  643.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  644. #ifdef WANT_TIM
  645.     return(8L);
  646. #endif
  647. }
  648.  
  649. static long op_rld()             /*    RL D */
  650. {
  651.     register int old_c_flag;
  652.  
  653.     old_c_flag = F & C_FLAG;
  654.     (D & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  655.     D <<= 1;
  656.     if (old_c_flag)    D |= 1;
  657.     F &= ~(H_FLAG |    N_FLAG);
  658.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  659.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  660.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  661. #ifdef WANT_TIM
  662.     return(8L);
  663. #endif
  664. }
  665.  
  666. static long op_rle()             /*    RL E */
  667. {
  668.     register int old_c_flag;
  669.  
  670.     old_c_flag = F & C_FLAG;
  671.     (E & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  672.     E <<= 1;
  673.     if (old_c_flag)    E |= 1;
  674.     F &= ~(H_FLAG |    N_FLAG);
  675.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  676.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  677.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  678. #ifdef WANT_TIM
  679.     return(8L);
  680. #endif
  681. }
  682.  
  683. static long op_rlh()             /*    RL H */
  684. {
  685.     register int old_c_flag;
  686.  
  687.     old_c_flag = F & C_FLAG;
  688.     (H & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  689.     H <<= 1;
  690.     if (old_c_flag)    H |= 1;
  691.     F &= ~(H_FLAG |    N_FLAG);
  692.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  693.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  694.     (parrity[H]) ? (F &= ~P_FLAG) :(F |= P_FLAG);
  695. #ifdef WANT_TIM
  696.     return(8L);
  697. #endif
  698. }
  699.  
  700. static long op_rll()             /*    RL L */
  701. {
  702.     register int old_c_flag;
  703.  
  704.     old_c_flag = F & C_FLAG;
  705.     (L & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  706.     L <<= 1;
  707.     if (old_c_flag)    L |= 1;
  708.     F &= ~(H_FLAG |    N_FLAG);
  709.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  710.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  711.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  712. #ifdef WANT_TIM
  713.     return(8L);
  714. #endif
  715. }
  716.  
  717. static long op_rlhl()             /*    RL (HL)    */
  718. {
  719.     register int old_c_flag;
  720.     register BYTE *p;
  721.  
  722.     p = ram    + (H <<    8) + L;
  723.     old_c_flag = F & C_FLAG;
  724.     (*p & 128) ? (F    |= C_FLAG) : (F    &= ~C_FLAG);
  725.     *p <<= 1;
  726.     if (old_c_flag)    *p |= 1;
  727.     F &= ~(H_FLAG |    N_FLAG);
  728.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  729.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  730.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  731. #ifdef WANT_TIM
  732.     return(15L);
  733. #endif
  734. }
  735.  
  736. static long op_rrra()             /*    RR A */
  737. {
  738.     register int old_c_flag;
  739.  
  740.     old_c_flag = F & C_FLAG;
  741.     (A & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  742.     A >>= 1;
  743.     if (old_c_flag)    A |= 128;
  744.     F &= ~(H_FLAG |    N_FLAG);
  745.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  746.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  747.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  748. #ifdef WANT_TIM
  749.     return(8L);
  750. #endif
  751. }
  752.  
  753. static long op_rrb()             /*    RR B */
  754. {
  755.     register int old_c_flag;
  756.  
  757.     old_c_flag = F & C_FLAG;
  758.     (B & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  759.     B >>= 1;
  760.     if (old_c_flag)    B |= 128;
  761.     F &= ~(H_FLAG |    N_FLAG);
  762.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  763.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  764.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  765. #ifdef WANT_TIM
  766.     return(8L);
  767. #endif
  768. }
  769.  
  770. static long op_rrc()             /*    RR C */
  771. {
  772.     register int old_c_flag;
  773.  
  774.     old_c_flag = F & C_FLAG;
  775.     (C & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  776.     C >>= 1;
  777.     if (old_c_flag)    C |= 128;
  778.     F &= ~(H_FLAG |    N_FLAG);
  779.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  780.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  781.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  782. #ifdef WANT_TIM
  783.     return(8L);
  784. #endif
  785. }
  786.  
  787. static long op_rrd()             /*    RR D */
  788. {
  789.     register int old_c_flag;
  790.  
  791.     old_c_flag = F & C_FLAG;
  792.     (D & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  793.     D >>= 1;
  794.     if (old_c_flag)    D |= 128;
  795.     F &= ~(H_FLAG |    N_FLAG);
  796.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  797.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  798.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  799. #ifdef WANT_TIM
  800.     return(8L);
  801. #endif
  802. }
  803.  
  804. static long op_rre()             /*    RR E */
  805. {
  806.     register int old_c_flag;
  807.  
  808.     old_c_flag = F & C_FLAG;
  809.     (E & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  810.     E >>= 1;
  811.     if (old_c_flag)    E |= 128;
  812.     F &= ~(H_FLAG |    N_FLAG);
  813.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  814.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  815.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  816. #ifdef WANT_TIM
  817.     return(8L);
  818. #endif
  819. }
  820.  
  821. static long op_rrh()             /*    RR H */
  822. {
  823.     register int old_c_flag;
  824.  
  825.     old_c_flag = F & C_FLAG;
  826.     (H & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  827.     H >>= 1;
  828.     if (old_c_flag)    H |= 128;
  829.     F &= ~(H_FLAG |    N_FLAG);
  830.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  831.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  832.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  833. #ifdef WANT_TIM
  834.     return(8L);
  835. #endif
  836. }
  837.  
  838. static long op_rrl()             /*    RR L */
  839. {
  840.     register int old_c_flag;
  841.  
  842.     old_c_flag = F & C_FLAG;
  843.     (L & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  844.     L >>= 1;
  845.     if (old_c_flag)    L |= 128;
  846.     F &= ~(H_FLAG |    N_FLAG);
  847.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  848.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  849.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  850. #ifdef WANT_TIM
  851.     return(8L);
  852. #endif
  853. }
  854.  
  855. static long op_rrhl()             /*    RR (HL)    */
  856. {
  857.     register int old_c_flag;
  858.     register BYTE *p;
  859.  
  860.     old_c_flag = F & C_FLAG;
  861.     p = ram    + (H <<    8) + L;
  862.     (*p & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  863.     *p >>= 1;
  864.     if (old_c_flag)    *p |= 128;
  865.     F &= ~(H_FLAG |    N_FLAG);
  866.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  867.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  868.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  869. #ifdef WANT_TIM
  870.     return(15L);
  871. #endif
  872. }
  873.  
  874. static long op_rrcra()             /*    RRC A */
  875. {
  876.     register int i;
  877.  
  878.     i = A &    1;
  879.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  880.     F &= ~(H_FLAG |    N_FLAG);
  881.     A >>= 1;
  882.     if (i) A |= 128;
  883.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  884.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  885.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  886. #ifdef WANT_TIM
  887.     return(8L);
  888. #endif
  889. }
  890.  
  891. static long op_rrcb()             /*    RRC B */
  892. {
  893.     register int i;
  894.  
  895.     i = B &    1;
  896.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  897.     F &= ~(H_FLAG |    N_FLAG);
  898.     B >>= 1;
  899.     if (i) B |= 128;
  900.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  901.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  902.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  903. #ifdef WANT_TIM
  904.     return(8L);
  905. #endif
  906. }
  907.  
  908. static long op_rrcc()             /*    RRC C */
  909. {
  910.     register int i;
  911.  
  912.     i = C &    1;
  913.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  914.     F &= ~(H_FLAG |    N_FLAG);
  915.     C >>= 1;
  916.     if (i) C |= 128;
  917.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  918.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  919.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  920. #ifdef WANT_TIM
  921.     return(8L);
  922. #endif
  923. }
  924.  
  925. static long op_rrcd()             /*    RRC D */
  926. {
  927.     register int i;
  928.  
  929.     i = D &    1;
  930.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  931.     F &= ~(H_FLAG |    N_FLAG);
  932.     D >>= 1;
  933.     if (i) D |= 128;
  934.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  935.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  936.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  937. #ifdef WANT_TIM
  938.     return(8L);
  939. #endif
  940. }
  941.  
  942. static long op_rrce()             /*    RRC E */
  943. {
  944.     register int i;
  945.  
  946.     i = E &    1;
  947.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  948.     F &= ~(H_FLAG |    N_FLAG);
  949.     E >>= 1;
  950.     if (i) E |= 128;
  951.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  952.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  953.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  954. #ifdef WANT_TIM
  955.     return(8L);
  956. #endif
  957. }
  958.  
  959. static long op_rrch()             /*    RRC H */
  960. {
  961.     register int i;
  962.  
  963.     i = H &    1;
  964.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  965.     F &= ~(H_FLAG |    N_FLAG);
  966.     H >>= 1;
  967.     if (i) H |= 128;
  968.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  969.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  970.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  971. #ifdef WANT_TIM
  972.     return(8L);
  973. #endif
  974. }
  975.  
  976. static long op_rrcl()             /*    RRC L */
  977. {
  978.     register int i;
  979.  
  980.     i = L &    1;
  981.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  982.     F &= ~(H_FLAG |    N_FLAG);
  983.     L >>= 1;
  984.     if (i) L |= 128;
  985.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  986.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  987.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  988. #ifdef WANT_TIM
  989.     return(8L);
  990. #endif
  991. }
  992.  
  993. static long op_rrchl()             /*    RRC (HL) */
  994. {
  995.     register int i;
  996.     register BYTE *p;
  997.  
  998.     p = ram    + (H <<    8) + L;
  999.     i = *p & 1;
  1000.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1001.     F &= ~(H_FLAG |    N_FLAG);
  1002.     *p >>= 1;
  1003.     if (i) *p |= 128;
  1004.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  1005.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  1006.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  1007. #ifdef WANT_TIM
  1008.     return(15L);
  1009. #endif
  1010. }
  1011.  
  1012. static long op_rlcra()             /*    RLC A */
  1013. {
  1014.     register int i;
  1015.  
  1016.     i = A &    128;
  1017.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1018.     F &= ~(H_FLAG |    N_FLAG);
  1019.     A <<= 1;
  1020.     if (i) A |= 1;
  1021.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1022.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1023.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1024. #ifdef WANT_TIM
  1025.     return(8L);
  1026. #endif
  1027. }
  1028.  
  1029. static long op_rlcb()             /*    RLC B */
  1030. {
  1031.     register int i;
  1032.  
  1033.     i = B &    128;
  1034.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1035.     F &= ~(H_FLAG |    N_FLAG);
  1036.     B <<= 1;
  1037.     if (i) B |= 1;
  1038.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1039.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1040.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1041. #ifdef WANT_TIM
  1042.     return(8L);
  1043. #endif
  1044. }
  1045.  
  1046. static long op_rlcc()             /*    RLC C */
  1047. {
  1048.     register int i;
  1049.  
  1050.     i = C &    128;
  1051.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1052.     F &= ~(H_FLAG |    N_FLAG);
  1053.     C <<= 1;
  1054.     if (i) C |= 1;
  1055.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1056.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1057.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1058. #ifdef WANT_TIM
  1059.     return(8L);
  1060. #endif
  1061. }
  1062.  
  1063. static long op_rlcd()             /*    RLC D */
  1064. {
  1065.     register int i;
  1066.  
  1067.     i = D &    128;
  1068.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1069.     F &= ~(H_FLAG |    N_FLAG);
  1070.     D <<= 1;
  1071.     if (i) D |= 1;
  1072.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1073.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1074.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1075. #ifdef WANT_TIM
  1076.     return(8L);
  1077. #endif
  1078. }
  1079.  
  1080. static long op_rlce()             /*    RLC E */
  1081. {
  1082.     register int i;
  1083.  
  1084.     i = E &    128;
  1085.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1086.     F &= ~(H_FLAG |    N_FLAG);
  1087.     E <<= 1;
  1088.     if (i) E |= 1;
  1089.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1090.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1091.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1092. #ifdef WANT_TIM
  1093.     return(8L);
  1094. #endif
  1095. }
  1096.  
  1097. static long op_rlch()             /*    RLC H */
  1098. {
  1099.     register int i;
  1100.  
  1101.     i = H &    128;
  1102.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1103.     F &= ~(H_FLAG |    N_FLAG);
  1104.     H <<= 1;
  1105.     if (i) H |= 1;
  1106.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1107.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1108.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1109. #ifdef WANT_TIM
  1110.     return(8L);
  1111. #endif
  1112. }
  1113.  
  1114. static long op_rlcl()             /*    RLC L */
  1115. {
  1116.     register int i;
  1117.  
  1118.     i = L &    128;
  1119.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1120.     F &= ~(H_FLAG |    N_FLAG);
  1121.     L <<= 1;
  1122.     if (i) L |= 1;
  1123.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1124.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1125.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1126. #ifdef WANT_TIM
  1127.     return(8L);
  1128. #endif
  1129. }
  1130.  
  1131. static long op_rlchl()             /*    RLC (HL) */
  1132. {
  1133.     register int i;
  1134.     register BYTE *p;
  1135.  
  1136.     p = ram    + (H <<    8) + L;
  1137.     i = *p & 128;
  1138.     (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1139.     F &= ~(H_FLAG |    N_FLAG);
  1140.     *p <<= 1;
  1141.     if (i) *p |= 1;
  1142.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  1143.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  1144.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  1145. #ifdef WANT_TIM
  1146.     return(15L);
  1147. #endif
  1148. }
  1149.  
  1150. static long op_sraa()             /*    SRA A */
  1151. {
  1152.     register int i;
  1153.  
  1154.     i = A &    128;
  1155.     (A & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1156.     A >>= 1;
  1157.     A |= i;
  1158.     F &= ~(H_FLAG |    N_FLAG);
  1159.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1160.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1161.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1162. #ifdef WANT_TIM
  1163.     return(8L);
  1164. #endif
  1165. }
  1166.  
  1167. static long op_srab()             /*    SRA B */
  1168. {
  1169.     register int i;
  1170.  
  1171.     i = B &    128;
  1172.     (B & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1173.     B >>= 1;
  1174.     B |= i;
  1175.     F &= ~(H_FLAG |    N_FLAG);
  1176.     (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1177.     (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1178.     (parrity[B]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1179. #ifdef WANT_TIM
  1180.     return(8L);
  1181. #endif
  1182. }
  1183.  
  1184. static long op_srac()             /*    SRA C */
  1185. {
  1186.     register int i;
  1187.  
  1188.     i = C &    128;
  1189.     (C & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1190.     C >>= 1;
  1191.     C |= i;
  1192.     F &= ~(H_FLAG |    N_FLAG);
  1193.     (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1194.     (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1195.     (parrity[C]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1196. #ifdef WANT_TIM
  1197.     return(8L);
  1198. #endif
  1199. }
  1200.  
  1201. static long op_srad()             /*    SRA D */
  1202. {
  1203.     register int i;
  1204.  
  1205.     i = D &    128;
  1206.     (D & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1207.     D >>= 1;
  1208.     D |= i;
  1209.     F &= ~(H_FLAG |    N_FLAG);
  1210.     (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1211.     (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1212.     (parrity[D]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1213. #ifdef WANT_TIM
  1214.     return(8L);
  1215. #endif
  1216. }
  1217.  
  1218. static long op_srae()             /*    SRA E */
  1219. {
  1220.     register int i;
  1221.  
  1222.     i = E &    128;
  1223.     (E & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1224.     E >>= 1;
  1225.     E |= i;
  1226.     F &= ~(H_FLAG |    N_FLAG);
  1227.     (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1228.     (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1229.     (parrity[E]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1230. #ifdef WANT_TIM
  1231.     return(8L);
  1232. #endif
  1233. }
  1234.  
  1235. static long op_srah()             /*    SRA H */
  1236. {
  1237.     register int i;
  1238.  
  1239.     i = H &    128;
  1240.     (H & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1241.     H >>= 1;
  1242.     H |= i;
  1243.     F &= ~(H_FLAG |    N_FLAG);
  1244.     (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1245.     (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1246.     (parrity[H]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1247. #ifdef WANT_TIM
  1248.     return(8L);
  1249. #endif
  1250. }
  1251.  
  1252. static long op_sral()             /*    SRA L */
  1253. {
  1254.     register int i;
  1255.  
  1256.     i = L &    128;
  1257.     (L & 1)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  1258.     L >>= 1;
  1259.     L |= i;
  1260.     F &= ~(H_FLAG |    N_FLAG);
  1261.     (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  1262.     (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  1263.     (parrity[L]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  1264. #ifdef WANT_TIM
  1265.     return(8L);
  1266. #endif
  1267. }
  1268.  
  1269. static long op_srahl()             /*    SRA (HL) */
  1270. {
  1271.     register int i;
  1272.     register BYTE *p;
  1273.  
  1274.     p = ram    + (H <<    8) + L;
  1275.     i = *p & 128;
  1276.     (*p & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
  1277.     *p >>= 1;
  1278.     *p |= i;
  1279.     F &= ~(H_FLAG |    N_FLAG);
  1280.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  1281.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  1282.     (parrity[*p]) ?    (F &= ~P_FLAG) : (F |= P_FLAG);
  1283. #ifdef WANT_TIM
  1284.     return(15L);
  1285. #endif
  1286. }
  1287.  
  1288. static long op_sb0a()             /*    SET 0,A    */
  1289. {
  1290.     A |= 1;
  1291. #ifdef WANT_TIM
  1292.     return(8L);
  1293. #endif
  1294. }
  1295.  
  1296. static long op_sb1a()             /*    SET 1,A    */
  1297. {
  1298.     A |= 2;
  1299. #ifdef WANT_TIM
  1300.     return(8L);
  1301. #endif
  1302. }
  1303.  
  1304. static long op_sb2a()             /*    SET 2,A    */
  1305. {
  1306.     A |= 4;
  1307. #ifdef WANT_TIM
  1308.     return(8L);
  1309. #endif
  1310. }
  1311.  
  1312. static long op_sb3a()             /*    SET 3,A    */
  1313. {
  1314.     A |= 8;
  1315. #ifdef WANT_TIM
  1316.     return(8L);
  1317. #endif
  1318. }
  1319.  
  1320. static long op_sb4a()             /*    SET 4,A    */
  1321. {
  1322.     A |= 16;
  1323. #ifdef WANT_TIM
  1324.     return(8L);
  1325. #endif
  1326. }
  1327.  
  1328. static long op_sb5a()             /*    SET 5,A    */
  1329. {
  1330.     A |= 32;
  1331. #ifdef WANT_TIM
  1332.     return(8L);
  1333. #endif
  1334. }
  1335.  
  1336. static long op_sb6a()             /*    SET 6,A    */
  1337. {
  1338.     A |= 64;
  1339. #ifdef WANT_TIM
  1340.     return(8L);
  1341. #endif
  1342. }
  1343.  
  1344. static long op_sb7a()             /*    SET 7,A    */
  1345. {
  1346.     A |= 128;
  1347. #ifdef WANT_TIM
  1348.     return(8L);
  1349. #endif
  1350. }
  1351.  
  1352. static long op_sb0b()             /*    SET 0,B    */
  1353. {
  1354.     B |= 1;
  1355. #ifdef WANT_TIM
  1356.     return(8L);
  1357. #endif
  1358. }
  1359.  
  1360. static long op_sb1b()             /*    SET 1,B    */
  1361. {
  1362.     B |= 2;
  1363. #ifdef WANT_TIM
  1364.     return(8L);
  1365. #endif
  1366. }
  1367.  
  1368. static long op_sb2b()             /*    SET 2,B    */
  1369. {
  1370.     B |= 4;
  1371. #ifdef WANT_TIM
  1372.     return(8L);
  1373. #endif
  1374. }
  1375.  
  1376. static long op_sb3b()             /*    SET 3,B    */
  1377. {
  1378.     B |= 8;
  1379. #ifdef WANT_TIM
  1380.     return(8L);
  1381. #endif
  1382. }
  1383.  
  1384. static long op_sb4b()             /*    SET 4,B    */
  1385. {
  1386.     B |= 16;
  1387. #ifdef WANT_TIM
  1388.     return(8L);
  1389. #endif
  1390. }
  1391.  
  1392. static long op_sb5b()             /*    SET 5,B    */
  1393. {
  1394.     B |= 32;
  1395. #ifdef WANT_TIM
  1396.     return(8L);
  1397. #endif
  1398. }
  1399.  
  1400. static long op_sb6b()             /*    SET 6,B    */
  1401. {
  1402.     B |= 64;
  1403. #ifdef WANT_TIM
  1404.     return(8L);
  1405. #endif
  1406. }
  1407.  
  1408. static long op_sb7b()             /*    SET 7,B    */
  1409. {
  1410.     B |= 128;
  1411. #ifdef WANT_TIM
  1412.     return(8L);
  1413. #endif
  1414. }
  1415.  
  1416. static long op_sb0c()             /*    SET 0,C    */
  1417. {
  1418.     C |= 1;
  1419. #ifdef WANT_TIM
  1420.     return(8L);
  1421. #endif
  1422. }
  1423.  
  1424. static long op_sb1c()             /*    SET 1,C    */
  1425. {
  1426.     C |= 2;
  1427. #ifdef WANT_TIM
  1428.     return(8L);
  1429. #endif
  1430. }
  1431.  
  1432. static long op_sb2c()             /*    SET 2,C    */
  1433. {
  1434.     C |= 4;
  1435. #ifdef WANT_TIM
  1436.     return(8L);
  1437. #endif
  1438. }
  1439.  
  1440. static long op_sb3c()             /*    SET 3,C    */
  1441. {
  1442.     C |= 8;
  1443. #ifdef WANT_TIM
  1444.     return(8L);
  1445. #endif
  1446. }
  1447.  
  1448. static long op_sb4c()             /*    SET 4,C    */
  1449. {
  1450.     C |= 16;
  1451. #ifdef WANT_TIM
  1452.     return(8L);
  1453. #endif
  1454. }
  1455.  
  1456. static long op_sb5c()             /*    SET 5,C    */
  1457. {
  1458.     C |= 32;
  1459. #ifdef WANT_TIM
  1460.     return(8L);
  1461. #endif
  1462. }
  1463.  
  1464. static long op_sb6c()             /*    SET 6,C    */
  1465. {
  1466.     C |= 64;
  1467. #ifdef WANT_TIM
  1468.     return(8L);
  1469. #endif
  1470. }
  1471.  
  1472. static long op_sb7c()             /*    SET 7,C    */
  1473. {
  1474.     C |= 128;
  1475. #ifdef WANT_TIM
  1476.     return(8L);
  1477. #endif
  1478. }
  1479.  
  1480. static long op_sb0d()             /*    SET 0,D    */
  1481. {
  1482.     D |= 1;
  1483. #ifdef WANT_TIM
  1484.     return(8L);
  1485. #endif
  1486. }
  1487.  
  1488. static long op_sb1d()             /*    SET 1,D    */
  1489. {
  1490.     D |= 2;
  1491. #ifdef WANT_TIM
  1492.     return(8L);
  1493. #endif
  1494. }
  1495.  
  1496. static long op_sb2d()             /*    SET 2,D    */
  1497. {
  1498.     D |= 4;
  1499. #ifdef WANT_TIM
  1500.     return(8L);
  1501. #endif
  1502. }
  1503.  
  1504. static long op_sb3d()             /*    SET 3,D    */
  1505. {
  1506.     D |= 8;
  1507. #ifdef WANT_TIM
  1508.     return(8L);
  1509. #endif
  1510. }
  1511.  
  1512. static long op_sb4d()             /*    SET 4,D    */
  1513. {
  1514.     D |= 16;
  1515. #ifdef WANT_TIM
  1516.     return(8L);
  1517. #endif
  1518. }
  1519.  
  1520. static long op_sb5d()             /*    SET 5,D    */
  1521. {
  1522.     D |= 32;
  1523. #ifdef WANT_TIM
  1524.     return(8L);
  1525. #endif
  1526. }
  1527.  
  1528. static long op_sb6d()             /*    SET 6,D    */
  1529. {
  1530.     D |= 64;
  1531. #ifdef WANT_TIM
  1532.     return(8L);
  1533. #endif
  1534. }
  1535.  
  1536. static long op_sb7d()             /*    SET 7,D    */
  1537. {
  1538.     D |= 128;
  1539. #ifdef WANT_TIM
  1540.     return(8L);
  1541. #endif
  1542. }
  1543.  
  1544. static long op_sb0e()             /*    SET 0,E    */
  1545. {
  1546.     E |= 1;
  1547. #ifdef WANT_TIM
  1548.     return(8L);
  1549. #endif
  1550. }
  1551.  
  1552. static long op_sb1e()             /*    SET 1,E    */
  1553. {
  1554.     E |= 2;
  1555. #ifdef WANT_TIM
  1556.     return(8L);
  1557. #endif
  1558. }
  1559.  
  1560. static long op_sb2e()             /*    SET 2,E    */
  1561. {
  1562.     E |= 4;
  1563. #ifdef WANT_TIM
  1564.     return(8L);
  1565. #endif
  1566. }
  1567.  
  1568. static long op_sb3e()             /*    SET 3,E    */
  1569. {
  1570.     E |= 8;
  1571. #ifdef WANT_TIM
  1572.     return(8L);
  1573. #endif
  1574. }
  1575.  
  1576. static long op_sb4e()             /*    SET 4,E    */
  1577. {
  1578.     E |= 16;
  1579. #ifdef WANT_TIM
  1580.     return(8L);
  1581. #endif
  1582. }
  1583.  
  1584. static long op_sb5e()             /*    SET 5,E    */
  1585. {
  1586.     E |= 32;
  1587. #ifdef WANT_TIM
  1588.     return(8L);
  1589. #endif
  1590. }
  1591.  
  1592. static long op_sb6e()             /*    SET 6,E    */
  1593. {
  1594.     E |= 64;
  1595. #ifdef WANT_TIM
  1596.     return(8L);
  1597. #endif
  1598. }
  1599.  
  1600. static long op_sb7e()             /*    SET 7,E    */
  1601. {
  1602.     E |= 128;
  1603. #ifdef WANT_TIM
  1604.     return(8L);
  1605. #endif
  1606. }
  1607.  
  1608. static long op_sb0h()             /*    SET 0,H    */
  1609. {
  1610.     H |= 1;
  1611. #ifdef WANT_TIM
  1612.     return(8L);
  1613. #endif
  1614. }
  1615.  
  1616. static long op_sb1h()             /*    SET 1,H    */
  1617. {
  1618.     H |= 2;
  1619. #ifdef WANT_TIM
  1620.     return(8L);
  1621. #endif
  1622. }
  1623.  
  1624. static long op_sb2h()             /*    SET 2,H    */
  1625. {
  1626.     H |= 4;
  1627. #ifdef WANT_TIM
  1628.     return(8L);
  1629. #endif
  1630. }
  1631.  
  1632. static long op_sb3h()             /*    SET 3,H    */
  1633. {
  1634.     H |= 8;
  1635. #ifdef WANT_TIM
  1636.     return(8L);
  1637. #endif
  1638. }
  1639.  
  1640. static long op_sb4h()             /*    SET 4,H    */
  1641. {
  1642.     H |= 16;
  1643. #ifdef WANT_TIM
  1644.     return(8L);
  1645. #endif
  1646. }
  1647.  
  1648. static long op_sb5h()             /*    SET 5,H    */
  1649. {
  1650.     H |= 32;
  1651. #ifdef WANT_TIM
  1652.     return(8L);
  1653. #endif
  1654. }
  1655.  
  1656. static long op_sb6h()             /*    SET 6,H    */
  1657. {
  1658.     H |= 64;
  1659. #ifdef WANT_TIM
  1660.     return(8L);
  1661. #endif
  1662. }
  1663.  
  1664. static long op_sb7h()             /*    SET 7,H    */
  1665. {
  1666.     H |= 128;
  1667. #ifdef WANT_TIM
  1668.     return(8L);
  1669. #endif
  1670. }
  1671.  
  1672. static long op_sb0l()             /*    SET 0,L    */
  1673. {
  1674.     L |= 1;
  1675. #ifdef WANT_TIM
  1676.     return(8L);
  1677. #endif
  1678. }
  1679.  
  1680. static long op_sb1l()             /*    SET 1,L    */
  1681. {
  1682.     L |= 2;
  1683. #ifdef WANT_TIM
  1684.     return(8L);
  1685. #endif
  1686. }
  1687.  
  1688. static long op_sb2l()             /*    SET 2,L    */
  1689. {
  1690.     L |= 4;
  1691. #ifdef WANT_TIM
  1692.     return(8L);
  1693. #endif
  1694. }
  1695.  
  1696. static long op_sb3l()             /*    SET 3,L    */
  1697. {
  1698.     L |= 8;
  1699. #ifdef WANT_TIM
  1700.     return(8L);
  1701. #endif
  1702. }
  1703.  
  1704. static long op_sb4l()             /*    SET 4,L    */
  1705. {
  1706.     L |= 16;
  1707. #ifdef WANT_TIM
  1708.     return(8L);
  1709. #endif
  1710. }
  1711.  
  1712. static long op_sb5l()             /*    SET 5,L    */
  1713. {
  1714.     L |= 32;
  1715. #ifdef WANT_TIM
  1716.     return(8L);
  1717. #endif
  1718. }
  1719.  
  1720. static long op_sb6l()             /*    SET 6,L    */
  1721. {
  1722.     L |= 64;
  1723. #ifdef WANT_TIM
  1724.     return(8L);
  1725. #endif
  1726. }
  1727.  
  1728. static long op_sb7l()             /*    SET 7,L    */
  1729. {
  1730.     L |= 128;
  1731. #ifdef WANT_TIM
  1732.     return(8L);
  1733. #endif
  1734. }
  1735.  
  1736. static long op_sb0hl()             /*    SET 0,(HL) */
  1737. {
  1738.     *(ram +    (H << 8) + L) |= 1;
  1739. #ifdef WANT_TIM
  1740.     return(15L);
  1741. #endif
  1742. }
  1743.  
  1744. static long op_sb1hl()             /*    SET 1,(HL) */
  1745. {
  1746.     *(ram +    (H << 8) + L) |= 2;
  1747. #ifdef WANT_TIM
  1748.     return(15L);
  1749. #endif
  1750. }
  1751.  
  1752. static long op_sb2hl()             /*    SET 2,(HL) */
  1753. {
  1754.     *(ram +    (H << 8) + L) |= 4;
  1755. #ifdef WANT_TIM
  1756.     return(15L);
  1757. #endif
  1758. }
  1759.  
  1760. static long op_sb3hl()             /*    SET 3,(HL) */
  1761. {
  1762.     *(ram +    (H << 8) + L) |= 8;
  1763. #ifdef WANT_TIM
  1764.     return(15L);
  1765. #endif
  1766. }
  1767.  
  1768. static long op_sb4hl()             /*    SET 4,(HL) */
  1769. {
  1770.     *(ram +    (H << 8) + L) |= 16;
  1771. #ifdef WANT_TIM
  1772.     return(15L);
  1773. #endif
  1774. }
  1775.  
  1776. static long op_sb5hl()             /*    SET 5,(HL) */
  1777. {
  1778.     *(ram +    (H << 8) + L) |= 32;
  1779. #ifdef WANT_TIM
  1780.     return(15L);
  1781. #endif
  1782. }
  1783.  
  1784. static long op_sb6hl()             /*    SET 6,(HL) */
  1785. {
  1786.     *(ram +    (H << 8) + L) |= 64;
  1787. #ifdef WANT_TIM
  1788.     return(15L);
  1789. #endif
  1790. }
  1791.  
  1792. static long op_sb7hl()             /*    SET 7,(HL) */
  1793. {
  1794.     *(ram +    (H << 8) + L) |= 128;
  1795. #ifdef WANT_TIM
  1796.     return(15L);
  1797. #endif
  1798. }
  1799.  
  1800. static long op_rb0a()             /*    RES 0,A    */
  1801. {
  1802.     A &= ~1;
  1803. #ifdef WANT_TIM
  1804.     return(8L);
  1805. #endif
  1806. }
  1807.  
  1808. static long op_rb1a()             /*    RES 1,A    */
  1809. {
  1810.     A &= ~2;
  1811. #ifdef WANT_TIM
  1812.     return(8L);
  1813. #endif
  1814. }
  1815.  
  1816. static long op_rb2a()             /*    RES 2,A    */
  1817. {
  1818.     A &= ~4;
  1819. #ifdef WANT_TIM
  1820.     return(8L);
  1821. #endif
  1822. }
  1823.  
  1824. static long op_rb3a()             /*    RES 3,A    */
  1825. {
  1826.     A &= ~8;
  1827. #ifdef WANT_TIM
  1828.     return(8L);
  1829. #endif
  1830. }
  1831.  
  1832. static long op_rb4a()             /*    RES 4,A    */
  1833. {
  1834.     A &= ~16;
  1835. #ifdef WANT_TIM
  1836.     return(8L);
  1837. #endif
  1838. }
  1839.  
  1840. static long op_rb5a()             /*    RES 5,A    */
  1841. {
  1842.     A &= ~32;
  1843. #ifdef WANT_TIM
  1844.     return(8L);
  1845. #endif
  1846. }
  1847.  
  1848. static long op_rb6a()             /*    RES 6,A    */
  1849. {
  1850.     A &= ~64;
  1851. #ifdef WANT_TIM
  1852.     return(8L);
  1853. #endif
  1854. }
  1855.  
  1856. static long op_rb7a()             /*    RES 7,A    */
  1857. {
  1858.     A &= ~128;
  1859. #ifdef WANT_TIM
  1860.     return(8L);
  1861. #endif
  1862. }
  1863.  
  1864. static long op_rb0b()             /*    RES 0,B    */
  1865. {
  1866.     B &= ~1;
  1867. #ifdef WANT_TIM
  1868.     return(8L);
  1869. #endif
  1870. }
  1871.  
  1872. static long op_rb1b()             /*    RES 1,B    */
  1873. {
  1874.     B &= ~2;
  1875. #ifdef WANT_TIM
  1876.     return(8L);
  1877. #endif
  1878. }
  1879.  
  1880. static long op_rb2b()             /*    RES 2,B    */
  1881. {
  1882.     B &= ~4;
  1883. #ifdef WANT_TIM
  1884.     return(8L);
  1885. #endif
  1886. }
  1887.  
  1888. static long op_rb3b()             /*    RES 3,B    */
  1889. {
  1890.     B &= ~8;
  1891. #ifdef WANT_TIM
  1892.     return(8L);
  1893. #endif
  1894. }
  1895.  
  1896. static long op_rb4b()             /*    RES 4,B    */
  1897. {
  1898.     B &= ~16;
  1899. #ifdef WANT_TIM
  1900.     return(8L);
  1901. #endif
  1902. }
  1903.  
  1904. static long op_rb5b()             /*    RES 5,B    */
  1905. {
  1906.     B &= ~32;
  1907. #ifdef WANT_TIM
  1908.     return(8L);
  1909. #endif
  1910. }
  1911.  
  1912. static long op_rb6b()             /*    RES 6,B    */
  1913. {
  1914.     B &= ~64;
  1915. #ifdef WANT_TIM
  1916.     return(8L);
  1917. #endif
  1918. }
  1919.  
  1920. static long op_rb7b()             /*    RES 7,B    */
  1921. {
  1922.     B &= ~128;
  1923. #ifdef WANT_TIM
  1924.     return(8L);
  1925. #endif
  1926. }
  1927.  
  1928. static long op_rb0c()             /*    RES 0,C    */
  1929. {
  1930.     C &= ~1;
  1931. #ifdef WANT_TIM
  1932.     return(8L);
  1933. #endif
  1934. }
  1935.  
  1936. static long op_rb1c()             /*    RES 1,C    */
  1937. {
  1938.     C &= ~2;
  1939. #ifdef WANT_TIM
  1940.     return(8L);
  1941. #endif
  1942. }
  1943.  
  1944. static long op_rb2c()             /*    RES 2,C    */
  1945. {
  1946.     C &= ~4;
  1947. #ifdef WANT_TIM
  1948.     return(8L);
  1949. #endif
  1950. }
  1951.  
  1952. static long op_rb3c()             /*    RES 3,C    */
  1953. {
  1954.     C &= ~8;
  1955. #ifdef WANT_TIM
  1956.     return(8L);
  1957. #endif
  1958. }
  1959.  
  1960. static long op_rb4c()             /*    RES 4,C    */
  1961. {
  1962.     C &= ~16;
  1963. #ifdef WANT_TIM
  1964.     return(8L);
  1965. #endif
  1966. }
  1967.  
  1968. static long op_rb5c()             /*    RES 5,C    */
  1969. {
  1970.     C &= ~32;
  1971. #ifdef WANT_TIM
  1972.     return(8L);
  1973. #endif
  1974. }
  1975.  
  1976. static long op_rb6c()             /*    RES 6,C    */
  1977. {
  1978.     C &= ~64;
  1979. #ifdef WANT_TIM
  1980.     return(8L);
  1981. #endif
  1982. }
  1983.  
  1984. static long op_rb7c()             /*    RES 7,C    */
  1985. {
  1986.     C &= ~128;
  1987. #ifdef WANT_TIM
  1988.     return(8L);
  1989. #endif
  1990. }
  1991.  
  1992. static long op_rb0d()             /*    RES 0,D    */
  1993. {
  1994.     D &= ~1;
  1995. #ifdef WANT_TIM
  1996.     return(8L);
  1997. #endif
  1998. }
  1999.  
  2000. static long op_rb1d()             /*    RES 1,D    */
  2001. {
  2002.     D &= ~2;
  2003. #ifdef WANT_TIM
  2004.     return(8L);
  2005. #endif
  2006. }
  2007.  
  2008. static long op_rb2d()             /*    RES 2,D    */
  2009. {
  2010.     D &= ~4;
  2011. #ifdef WANT_TIM
  2012.     return(8L);
  2013. #endif
  2014. }
  2015.  
  2016. static long op_rb3d()             /*    RES 3,D    */
  2017. {
  2018.     D &= ~8;
  2019. #ifdef WANT_TIM
  2020.     return(8L);
  2021. #endif
  2022. }
  2023.  
  2024. static long op_rb4d()             /*    RES 4,D    */
  2025. {
  2026.     D &= ~16;
  2027. #ifdef WANT_TIM
  2028.     return(8L);
  2029. #endif
  2030. }
  2031.  
  2032. static long op_rb5d()             /*    RES 5,D    */
  2033. {
  2034.     D &= ~32;
  2035. #ifdef WANT_TIM
  2036.     return(8L);
  2037. #endif
  2038. }
  2039.  
  2040. static long op_rb6d()             /*    RES 6,D    */
  2041. {
  2042.     D &= ~64;
  2043. #ifdef WANT_TIM
  2044.     return(8L);
  2045. #endif
  2046. }
  2047.  
  2048. static long op_rb7d()             /*    RES 7,D    */
  2049. {
  2050.     D &= ~128;
  2051. #ifdef WANT_TIM
  2052.     return(8L);
  2053. #endif
  2054. }
  2055.  
  2056. static long op_rb0e()             /*    RES 0,E    */
  2057. {
  2058.     E &= ~1;
  2059. #ifdef WANT_TIM
  2060.     return(8L);
  2061. #endif
  2062. }
  2063.  
  2064. static long op_rb1e()             /*    RES 1,E    */
  2065. {
  2066.     E &= ~2;
  2067. #ifdef WANT_TIM
  2068.     return(8L);
  2069. #endif
  2070. }
  2071.  
  2072. static long op_rb2e()             /*    RES 2,E    */
  2073. {
  2074.     E &= ~4;
  2075. #ifdef WANT_TIM
  2076.     return(8L);
  2077. #endif
  2078. }
  2079.  
  2080. static long op_rb3e()             /*    RES 3,E    */
  2081. {
  2082.     E &= ~8;
  2083. #ifdef WANT_TIM
  2084.     return(8L);
  2085. #endif
  2086. }
  2087.  
  2088. static long op_rb4e()             /*    RES 4,E    */
  2089. {
  2090.     E &= ~16;
  2091. #ifdef WANT_TIM
  2092.     return(8L);
  2093. #endif
  2094. }
  2095.  
  2096. static long op_rb5e()             /*    RES 5,E    */
  2097. {
  2098.     E &= ~32;
  2099. #ifdef WANT_TIM
  2100.     return(8L);
  2101. #endif
  2102. }
  2103.  
  2104. static long op_rb6e()             /*    RES 6,E    */
  2105. {
  2106.     E &= ~64;
  2107. #ifdef WANT_TIM
  2108.     return(8L);
  2109. #endif
  2110. }
  2111.  
  2112. static long op_rb7e()             /*    RES 7,E    */
  2113. {
  2114.     E &= ~128;
  2115. #ifdef WANT_TIM
  2116.     return(8L);
  2117. #endif
  2118. }
  2119.  
  2120. static long op_rb0h()             /*    RES 0,H    */
  2121. {
  2122.     H &= ~1;
  2123. #ifdef WANT_TIM
  2124.     return(8L);
  2125. #endif
  2126. }
  2127.  
  2128. static long op_rb1h()             /*    RES 1,H    */
  2129. {
  2130.     H &= ~2;
  2131. #ifdef WANT_TIM
  2132.     return(8L);
  2133. #endif
  2134. }
  2135.  
  2136. static long op_rb2h()             /*    RES 2,H    */
  2137. {
  2138.     H &= ~4;
  2139. #ifdef WANT_TIM
  2140.     return(8L);
  2141. #endif
  2142. }
  2143.  
  2144. static long op_rb3h()             /*    RES 3,H    */
  2145. {
  2146.     H &= ~8;
  2147. #ifdef WANT_TIM
  2148.     return(8L);
  2149. #endif
  2150. }
  2151.  
  2152. static long op_rb4h()             /*    RES 4,H    */
  2153. {
  2154.     H &= ~16;
  2155. #ifdef WANT_TIM
  2156.     return(8L);
  2157. #endif
  2158. }
  2159.  
  2160. static long op_rb5h()             /*    RES 5,H    */
  2161. {
  2162.     H &= ~32;
  2163. #ifdef WANT_TIM
  2164.     return(8L);
  2165. #endif
  2166. }
  2167.  
  2168. static long op_rb6h()             /*    RES 6,H    */
  2169. {
  2170.     H &= ~64;
  2171. #ifdef WANT_TIM
  2172.     return(8L);
  2173. #endif
  2174. }
  2175.  
  2176. static long op_rb7h()             /*    RES 7,H    */
  2177. {
  2178.     H &= ~128;
  2179. #ifdef WANT_TIM
  2180.     return(8L);
  2181. #endif
  2182. }
  2183.  
  2184. static long op_rb0l()             /*    RES 0,L    */
  2185. {
  2186.     L &= ~1;
  2187. #ifdef WANT_TIM
  2188.     return(8L);
  2189. #endif
  2190. }
  2191.  
  2192. static long op_rb1l()             /*    RES 1,L    */
  2193. {
  2194.     L &= ~2;
  2195. #ifdef WANT_TIM
  2196.     return(8L);
  2197. #endif
  2198. }
  2199.  
  2200. static long op_rb2l()             /*    RES 2,L    */
  2201. {
  2202.     L &= ~4;
  2203. #ifdef WANT_TIM
  2204.     return(8L);
  2205. #endif
  2206. }
  2207.  
  2208. static long op_rb3l()             /*    RES 3,L    */
  2209. {
  2210.     L &= ~8;
  2211. #ifdef WANT_TIM
  2212.     return(8L);
  2213. #endif
  2214. }
  2215.  
  2216. static long op_rb4l()             /*    RES 4,L    */
  2217. {
  2218.     L &= ~16;
  2219. #ifdef WANT_TIM
  2220.     return(8L);
  2221. #endif
  2222. }
  2223.  
  2224. static long op_rb5l()             /*    RES 5,L    */
  2225. {
  2226.     L &= ~32;
  2227. #ifdef WANT_TIM
  2228.     return(8L);
  2229. #endif
  2230. }
  2231.  
  2232. static long op_rb6l()             /*    RES 6,L    */
  2233. {
  2234.     L &= ~64;
  2235. #ifdef WANT_TIM
  2236.     return(8L);
  2237. #endif
  2238. }
  2239.  
  2240. static long op_rb7l()             /*    RES 7,L    */
  2241. {
  2242.     L &= ~128;
  2243. #ifdef WANT_TIM
  2244.     return(8L);
  2245. #endif
  2246. }
  2247.  
  2248. static long op_rb0hl()             /*    RES 0,(HL) */
  2249. {
  2250.     *(ram +    (H << 8) + L) &= ~1;
  2251. #ifdef WANT_TIM
  2252.     return(15L);
  2253. #endif
  2254. }
  2255.  
  2256. static long op_rb1hl()             /*    RES 1,(HL) */
  2257. {
  2258.     *(ram +    (H << 8) + L) &= ~2;
  2259. #ifdef WANT_TIM
  2260.     return(15L);
  2261. #endif
  2262. }
  2263.  
  2264. static long op_rb2hl()             /*    RES 2,(HL) */
  2265. {
  2266.     *(ram +    (H << 8) + L) &= ~4;
  2267. #ifdef WANT_TIM
  2268.     return(15L);
  2269. #endif
  2270. }
  2271.  
  2272. static long op_rb3hl()             /*    RES 3,(HL) */
  2273. {
  2274.     *(ram +    (H << 8) + L) &= ~8;
  2275. #ifdef WANT_TIM
  2276.     return(15L);
  2277. #endif
  2278. }
  2279.  
  2280. static long op_rb4hl()             /*    RES 4,(HL) */
  2281. {
  2282.     *(ram +    (H << 8) + L) &= ~16;
  2283. #ifdef WANT_TIM
  2284.     return(15L);
  2285. #endif
  2286. }
  2287.  
  2288. static long op_rb5hl()             /*    RES 5,(HL) */
  2289. {
  2290.     *(ram +    (H << 8) + L) &= ~32;
  2291. #ifdef WANT_TIM
  2292.     return(15L);
  2293. #endif
  2294. }
  2295.  
  2296. static long op_rb6hl()             /*    RES 6,(HL) */
  2297. {
  2298.     *(ram +    (H << 8) + L) &= ~64;
  2299. #ifdef WANT_TIM
  2300.     return(15L);
  2301. #endif
  2302. }
  2303.  
  2304. static long op_rb7hl()             /*    RES 7,(HL) */
  2305. {
  2306.     *(ram +    (H << 8) + L) &= ~128;
  2307. #ifdef WANT_TIM
  2308.     return(15L);
  2309. #endif
  2310. }
  2311.  
  2312. static long op_tb0a()             /*    BIT 0,A    */
  2313. {
  2314.     F &= ~N_FLAG;
  2315.     F |= H_FLAG;
  2316.     (A & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2317. #ifdef WANT_TIM
  2318.     return(8L);
  2319. #endif
  2320. }
  2321.  
  2322. static long op_tb1a()             /*    BIT 1,A    */
  2323. {
  2324.     F &= ~N_FLAG;
  2325.     F |= H_FLAG;
  2326.     (A & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2327. #ifdef WANT_TIM
  2328.     return(8L);
  2329. #endif
  2330. }
  2331.  
  2332. static long op_tb2a()             /*    BIT 2,A    */
  2333. {
  2334.     F &= ~N_FLAG;
  2335.     F |= H_FLAG;
  2336.     (A & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2337. #ifdef WANT_TIM
  2338.     return(8L);
  2339. #endif
  2340. }
  2341.  
  2342. static long op_tb3a()             /*    BIT 3,A    */
  2343. {
  2344.     F &= ~N_FLAG;
  2345.     F |= H_FLAG;
  2346.     (A & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2347. #ifdef WANT_TIM
  2348.     return(8L);
  2349. #endif
  2350. }
  2351.  
  2352. static long op_tb4a()             /*    BIT 4,A    */
  2353. {
  2354.     F &= ~N_FLAG;
  2355.     F |= H_FLAG;
  2356.     (A & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2357. #ifdef WANT_TIM
  2358.     return(8L);
  2359. #endif
  2360. }
  2361.  
  2362. static long op_tb5a()             /*    BIT 5,A    */
  2363. {
  2364.     F &= ~N_FLAG;
  2365.     F |= H_FLAG;
  2366.     (A & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2367. #ifdef WANT_TIM
  2368.     return(8L);
  2369. #endif
  2370. }
  2371.  
  2372. static long op_tb6a()             /*    BIT 6,A    */
  2373. {
  2374.     F &= ~N_FLAG;
  2375.     F |= H_FLAG;
  2376.     (A & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2377. #ifdef WANT_TIM
  2378.     return(8L);
  2379. #endif
  2380. }
  2381.  
  2382. static long op_tb7a()             /*    BIT 7,A    */
  2383. {
  2384.     F &= ~N_FLAG;
  2385.     F |= H_FLAG;
  2386.     (A & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2387. #ifdef WANT_TIM
  2388.     return(8L);
  2389. #endif
  2390. }
  2391.  
  2392. static long op_tb0b()             /*    BIT 0,B    */
  2393. {
  2394.     F &= ~N_FLAG;
  2395.     F |= H_FLAG;
  2396.     (B & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2397. #ifdef WANT_TIM
  2398.     return(8L);
  2399. #endif
  2400. }
  2401.  
  2402. static long op_tb1b()             /*    BIT 1,B    */
  2403. {
  2404.     F &= ~N_FLAG;
  2405.     F |= H_FLAG;
  2406.     (B & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2407. #ifdef WANT_TIM
  2408.     return(8L);
  2409. #endif
  2410. }
  2411.  
  2412. static long op_tb2b()             /*    BIT 2,B    */
  2413. {
  2414.     F &= ~N_FLAG;
  2415.     F |= H_FLAG;
  2416.     (B & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2417. #ifdef WANT_TIM
  2418.     return(8L);
  2419. #endif
  2420. }
  2421.  
  2422. static long op_tb3b()             /*    BIT 3,B    */
  2423. {
  2424.     F &= ~N_FLAG;
  2425.     F |= H_FLAG;
  2426.     (B & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2427. #ifdef WANT_TIM
  2428.     return(8L);
  2429. #endif
  2430. }
  2431.  
  2432. static long op_tb4b()             /*    BIT 4,B    */
  2433. {
  2434.     F &= ~N_FLAG;
  2435.     F |= H_FLAG;
  2436.     (B & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2437. #ifdef WANT_TIM
  2438.     return(8L);
  2439. #endif
  2440. }
  2441.  
  2442. static long op_tb5b()             /*    BIT 5,B    */
  2443. {
  2444.     F &= ~N_FLAG;
  2445.     F |= H_FLAG;
  2446.     (B & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2447. #ifdef WANT_TIM
  2448.     return(8L);
  2449. #endif
  2450. }
  2451.  
  2452. static long op_tb6b()             /*    BIT 6,B    */
  2453. {
  2454.     F &= ~N_FLAG;
  2455.     F |= H_FLAG;
  2456.     (B & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2457. #ifdef WANT_TIM
  2458.     return(8L);
  2459. #endif
  2460. }
  2461.  
  2462. static long op_tb7b()             /*    BIT 7,B    */
  2463. {
  2464.     F &= ~N_FLAG;
  2465.     F |= H_FLAG;
  2466.     (B & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2467. #ifdef WANT_TIM
  2468.     return(8L);
  2469. #endif
  2470. }
  2471.  
  2472. static long op_tb0c()             /*    BIT 0,C    */
  2473. {
  2474.     F &= ~N_FLAG;
  2475.     F |= H_FLAG;
  2476.     (C & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2477. #ifdef WANT_TIM
  2478.     return(8L);
  2479. #endif
  2480. }
  2481.  
  2482. static long op_tb1c()             /*    BIT 1,C    */
  2483. {
  2484.     F &= ~N_FLAG;
  2485.     F |= H_FLAG;
  2486.     (C & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2487. #ifdef WANT_TIM
  2488.     return(8L);
  2489. #endif
  2490. }
  2491.  
  2492. static long op_tb2c()             /*    BIT 2,C    */
  2493. {
  2494.     F &= ~N_FLAG;
  2495.     F |= H_FLAG;
  2496.     (C & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2497. #ifdef WANT_TIM
  2498.     return(8L);
  2499. #endif
  2500. }
  2501.  
  2502. static long op_tb3c()             /*    BIT 3,C    */
  2503. {
  2504.     F &= ~N_FLAG;
  2505.     F |= H_FLAG;
  2506.     (C & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2507. #ifdef WANT_TIM
  2508.     return(8L);
  2509. #endif
  2510. }
  2511.  
  2512. static long op_tb4c()             /*    BIT 4,C    */
  2513. {
  2514.     F &= ~N_FLAG;
  2515.     F |= H_FLAG;
  2516.     (C & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2517. #ifdef WANT_TIM
  2518.     return(8L);
  2519. #endif
  2520. }
  2521.  
  2522. static long op_tb5c()             /*    BIT 5,C    */
  2523. {
  2524.     F &= ~N_FLAG;
  2525.     F |= H_FLAG;
  2526.     (C & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2527. #ifdef WANT_TIM
  2528.     return(8L);
  2529. #endif
  2530. }
  2531.  
  2532. static long op_tb6c()             /*    BIT 6,C    */
  2533. {
  2534.     F &= ~N_FLAG;
  2535.     F |= H_FLAG;
  2536.     (C & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2537. #ifdef WANT_TIM
  2538.     return(8L);
  2539. #endif
  2540. }
  2541.  
  2542. static long op_tb7c()             /*    BIT 7,C    */
  2543. {
  2544.     F &= ~N_FLAG;
  2545.     F |= H_FLAG;
  2546.     (C & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2547. #ifdef WANT_TIM
  2548.     return(8L);
  2549. #endif
  2550. }
  2551.  
  2552. static long op_tb0d()             /*    BIT 0,D    */
  2553. {
  2554.     F &= ~N_FLAG;
  2555.     F |= H_FLAG;
  2556.     (D & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2557. #ifdef WANT_TIM
  2558.     return(8L);
  2559. #endif
  2560. }
  2561.  
  2562. static long op_tb1d()             /*    BIT 1,D    */
  2563. {
  2564.     F &= ~N_FLAG;
  2565.     F |= H_FLAG;
  2566.     (D & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2567. #ifdef WANT_TIM
  2568.     return(8L);
  2569. #endif
  2570. }
  2571.  
  2572. static long op_tb2d()             /*    BIT 2,D    */
  2573. {
  2574.     F &= ~N_FLAG;
  2575.     F |= H_FLAG;
  2576.     (D & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2577. #ifdef WANT_TIM
  2578.     return(8L);
  2579. #endif
  2580. }
  2581.  
  2582. static long op_tb3d()             /*    BIT 3,D    */
  2583. {
  2584.     F &= ~N_FLAG;
  2585.     F |= H_FLAG;
  2586.     (D & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2587. #ifdef WANT_TIM
  2588.     return(8L);
  2589. #endif
  2590. }
  2591.  
  2592. static long op_tb4d()             /*    BIT 4,D    */
  2593. {
  2594.     F &= ~N_FLAG;
  2595.     F |= H_FLAG;
  2596.     (D & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2597. #ifdef WANT_TIM
  2598.     return(8L);
  2599. #endif
  2600. }
  2601.  
  2602. static long op_tb5d()             /*    BIT 5,D    */
  2603. {
  2604.     F &= ~N_FLAG;
  2605.     F |= H_FLAG;
  2606.     (D & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2607. #ifdef WANT_TIM
  2608.     return(8L);
  2609. #endif
  2610. }
  2611.  
  2612. static long op_tb6d()             /*    BIT 6,D    */
  2613. {
  2614.     F &= ~N_FLAG;
  2615.     F |= H_FLAG;
  2616.     (D & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2617. #ifdef WANT_TIM
  2618.     return(8L);
  2619. #endif
  2620. }
  2621.  
  2622. static long op_tb7d()             /*    BIT 7,D    */
  2623. {
  2624.     F &= ~N_FLAG;
  2625.     F |= H_FLAG;
  2626.     (D & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2627. #ifdef WANT_TIM
  2628.     return(8L);
  2629. #endif
  2630. }
  2631.  
  2632. static long op_tb0e()             /*    BIT 0,E    */
  2633. {
  2634.     F &= ~N_FLAG;
  2635.     F |= H_FLAG;
  2636.     (E & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2637. #ifdef WANT_TIM
  2638.     return(8L);
  2639. #endif
  2640. }
  2641.  
  2642. static long op_tb1e()             /*    BIT 1,E    */
  2643. {
  2644.     F &= ~N_FLAG;
  2645.     F |= H_FLAG;
  2646.     (E & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2647. #ifdef WANT_TIM
  2648.     return(8L);
  2649. #endif
  2650. }
  2651.  
  2652. static long op_tb2e()             /*    BIT 2,E    */
  2653. {
  2654.     F &= ~N_FLAG;
  2655.     F |= H_FLAG;
  2656.     (E & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2657. #ifdef WANT_TIM
  2658.     return(8L);
  2659. #endif
  2660. }
  2661.  
  2662. static long op_tb3e()             /*    BIT 3,E    */
  2663. {
  2664.     F &= ~N_FLAG;
  2665.     F |= H_FLAG;
  2666.     (E & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2667. #ifdef WANT_TIM
  2668.     return(8L);
  2669. #endif
  2670. }
  2671.  
  2672. static long op_tb4e()             /*    BIT 4,E    */
  2673. {
  2674.     F &= ~N_FLAG;
  2675.     F |= H_FLAG;
  2676.     (E & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2677. #ifdef WANT_TIM
  2678.     return(8L);
  2679. #endif
  2680. }
  2681.  
  2682. static long op_tb5e()             /*    BIT 5,E    */
  2683. {
  2684.     F &= ~N_FLAG;
  2685.     F |= H_FLAG;
  2686.     (E & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2687. #ifdef WANT_TIM
  2688.     return(8L);
  2689. #endif
  2690. }
  2691.  
  2692. static long op_tb6e()             /*    BIT 6,E    */
  2693. {
  2694.     F &= ~N_FLAG;
  2695.     F |= H_FLAG;
  2696.     (E & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2697. #ifdef WANT_TIM
  2698.     return(8L);
  2699. #endif
  2700. }
  2701.  
  2702. static long op_tb7e()             /*    BIT 7,E    */
  2703. {
  2704.     F &= ~N_FLAG;
  2705.     F |= H_FLAG;
  2706.     (E & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2707. #ifdef WANT_TIM
  2708.     return(8L);
  2709. #endif
  2710. }
  2711.  
  2712. static long op_tb0h()             /*    BIT 0,H    */
  2713. {
  2714.     F &= ~N_FLAG;
  2715.     F |= H_FLAG;
  2716.     (H & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2717. #ifdef WANT_TIM
  2718.     return(8L);
  2719. #endif
  2720. }
  2721.  
  2722. static long op_tb1h()             /*    BIT 1,H    */
  2723. {
  2724.     F &= ~N_FLAG;
  2725.     F |= H_FLAG;
  2726.     (H & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2727. #ifdef WANT_TIM
  2728.     return(8L);
  2729. #endif
  2730. }
  2731.  
  2732. static long op_tb2h()             /*    BIT 2,H    */
  2733. {
  2734.     F &= ~N_FLAG;
  2735.     F |= H_FLAG;
  2736.     (H & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2737. #ifdef WANT_TIM
  2738.     return(8L);
  2739. #endif
  2740. }
  2741.  
  2742. static long op_tb3h()             /*    BIT 3,H    */
  2743. {
  2744.     F &= ~N_FLAG;
  2745.     F |= H_FLAG;
  2746.     (H & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2747. #ifdef WANT_TIM
  2748.     return(8L);
  2749. #endif
  2750. }
  2751.  
  2752. static long op_tb4h()             /*    BIT 4,H    */
  2753. {
  2754.     F &= ~N_FLAG;
  2755.     F |= H_FLAG;
  2756.     (H & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2757. #ifdef WANT_TIM
  2758.     return(8L);
  2759. #endif
  2760. }
  2761.  
  2762. static long op_tb5h()             /*    BIT 5,H    */
  2763. {
  2764.     F &= ~N_FLAG;
  2765.     F |= H_FLAG;
  2766.     (H & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2767. #ifdef WANT_TIM
  2768.     return(8L);
  2769. #endif
  2770. }
  2771.  
  2772. static long op_tb6h()             /*    BIT 6,H    */
  2773. {
  2774.     F &= ~N_FLAG;
  2775.     F |= H_FLAG;
  2776.     (H & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2777. #ifdef WANT_TIM
  2778.     return(8L);
  2779. #endif
  2780. }
  2781.  
  2782. static long op_tb7h()             /*    BIT 7,H    */
  2783. {
  2784.     F &= ~N_FLAG;
  2785.     F |= H_FLAG;
  2786.     (H & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2787. #ifdef WANT_TIM
  2788.     return(8L);
  2789. #endif
  2790. }
  2791.  
  2792. static long op_tb0l()             /*    BIT 0,L    */
  2793. {
  2794.     F &= ~N_FLAG;
  2795.     F |= H_FLAG;
  2796.     (L & 1)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2797. #ifdef WANT_TIM
  2798.     return(8L);
  2799. #endif
  2800. }
  2801.  
  2802. static long op_tb1l()             /*    BIT 1,L    */
  2803. {
  2804.     F &= ~N_FLAG;
  2805.     F |= H_FLAG;
  2806.     (L & 2)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2807. #ifdef WANT_TIM
  2808.     return(8L);
  2809. #endif
  2810. }
  2811.  
  2812. static long op_tb2l()             /*    BIT 2,L    */
  2813. {
  2814.     F &= ~N_FLAG;
  2815.     F |= H_FLAG;
  2816.     (L & 4)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2817. #ifdef WANT_TIM
  2818.     return(8L);
  2819. #endif
  2820. }
  2821.  
  2822. static long op_tb3l()             /*    BIT 3,L    */
  2823. {
  2824.     F &= ~N_FLAG;
  2825.     F |= H_FLAG;
  2826.     (L & 8)    ? (F &=    ~Z_FLAG) : (F |= Z_FLAG);
  2827. #ifdef WANT_TIM
  2828.     return(8L);
  2829. #endif
  2830. }
  2831.  
  2832. static long op_tb4l()             /*    BIT 4,L    */
  2833. {
  2834.     F &= ~N_FLAG;
  2835.     F |= H_FLAG;
  2836.     (L & 16) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2837. #ifdef WANT_TIM
  2838.     return(8L);
  2839. #endif
  2840. }
  2841.  
  2842. static long op_tb5l()             /*    BIT 5,L    */
  2843. {
  2844.     F &= ~N_FLAG;
  2845.     F |= H_FLAG;
  2846.     (L & 32) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2847. #ifdef WANT_TIM
  2848.     return(8L);
  2849. #endif
  2850. }
  2851.  
  2852. static long op_tb6l()             /*    BIT 6,L    */
  2853. {
  2854.     F &= ~N_FLAG;
  2855.     F |= H_FLAG;
  2856.     (L & 64) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2857. #ifdef WANT_TIM
  2858.     return(8L);
  2859. #endif
  2860. }
  2861.  
  2862. static long op_tb7l()             /*    BIT 7,L    */
  2863. {
  2864.     F &= ~N_FLAG;
  2865.     F |= H_FLAG;
  2866.     (L & 128) ? (F &= ~Z_FLAG) : (F    |= Z_FLAG);
  2867. #ifdef WANT_TIM
  2868.     return(8L);
  2869. #endif
  2870. }
  2871.  
  2872. static long op_tb0hl()             /*    BIT 0,(HL) */
  2873. {
  2874.     F &= ~N_FLAG;
  2875.     F |= H_FLAG;
  2876.     (*(ram + (H << 8) + L) & 1) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2877. #ifdef WANT_TIM
  2878.     return(12L);
  2879. #endif
  2880. }
  2881.  
  2882. static long op_tb1hl()             /*    BIT 1,(HL) */
  2883. {
  2884.     F &= ~N_FLAG;
  2885.     F |= H_FLAG;
  2886.     (*(ram + (H << 8) + L) & 2) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2887. #ifdef WANT_TIM
  2888.     return(12L);
  2889. #endif
  2890. }
  2891.  
  2892. static long op_tb2hl()             /*    BIT 2,(HL) */
  2893. {
  2894.     F &= ~N_FLAG;
  2895.     F |= H_FLAG;
  2896.     (*(ram + (H << 8) + L) & 4) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2897. #ifdef WANT_TIM
  2898.     return(12L);
  2899. #endif
  2900. }
  2901.  
  2902. static long op_tb3hl()             /*    BIT 3,(HL) */
  2903. {
  2904.     F &= ~N_FLAG;
  2905.     F |= H_FLAG;
  2906.     (*(ram + (H << 8) + L) & 8) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2907. #ifdef WANT_TIM
  2908.     return(12L);
  2909. #endif
  2910. }
  2911.  
  2912. static long op_tb4hl()             /*    BIT 4,(HL) */
  2913. {
  2914.     F &= ~N_FLAG;
  2915.     F |= H_FLAG;
  2916.     (*(ram + (H << 8) + L) & 16) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  2917. #ifdef WANT_TIM
  2918.     return(12L);
  2919. #endif
  2920. }
  2921.  
  2922. static long op_tb5hl()             /*    BIT 5,(HL) */
  2923. {
  2924.     F &= ~N_FLAG;
  2925.     F |= H_FLAG;
  2926.     (*(ram + (H << 8) + L) & 32) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  2927. #ifdef WANT_TIM
  2928.     return(12L);
  2929. #endif
  2930. }
  2931.  
  2932. static long op_tb6hl()             /*    BIT 6,(HL) */
  2933. {
  2934.     F &= ~N_FLAG;
  2935.     F |= H_FLAG;
  2936.     (*(ram + (H << 8) + L) & 64) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  2937. #ifdef WANT_TIM
  2938.     return(12L);
  2939. #endif
  2940. }
  2941.  
  2942. static long op_tb7hl()             /*    BIT 7,(HL) */
  2943. {
  2944.     F &= ~N_FLAG;
  2945.     F |= H_FLAG;
  2946.     (*(ram + (H << 8) + L) & 128) ?    (F &= ~Z_FLAG) : (F |= Z_FLAG);
  2947. #ifdef WANT_TIM
  2948.     return(12L);
  2949. #endif
  2950. }
  2951.  
  2952.