/*
 * ============================================================================
 *  OP_EXEC:        Execute functions for the CP-1610 instructions
 *
 *  Author:         J. Zbiciak
 *  Last Revision:  9/12/98
 * ============================================================================
 *  fn_invalid      -- Executed when a decoder failure happens
 *  fn_XXXX_i       -- Immediate operand instructions (relative branch, jump)
 *  fn_XXXX_r       -- Implied, register 2-ops (eg. ADCR, COMR, etc.)
 *  fn_XXXX_ir      -- Immediate, register 2-ops, JSR
 *  fn_XXXX_Ir      -- Immediate (no DBD), register 2-ops, JSR
 *  fn_XXXX_rr      -- Register, register 2-ops
 *  fn_XXXX_dr      -- Direct, register 2-ops
 *  fn_XXXX_mr      -- Indirect ("memory"), register 2-ops, non-incrementing
 *  fn_XXXX_Mr      -- Indirect ("memory"), register 2-ops, post-incrementing
 *  fn_XXXX_Nr      -- Indirect (no DBD),  register 2-ops, post-incrementing
 *  fn_XXXX_Sr      -- Indirect ("stack"), register 2-ops, pre-decrementing
 * ============================================================================
 */

#include "config.h"
#include <stdio.h>
#include "cp_1610.h"
#include "op_decode.h"
#include "op_exec.h"

int fn_invalid  (const instr_t *instr, cpu_t *cpu)
{
    int ws;

    fprintf(stderr, "Invalid opcode @ 0x%.4X : %.4X %.4X %.4X\n",
            instr->address, 
            CPU_RD(cpu, &ws, instr->address + 0),
            CPU_RD(cpu, &ws, instr->address + 1),
            CPU_RD(cpu, &ws, instr->address + 2));

    cpu->r[7]++;

    return 0;
}

int fn_BEXT_i   (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    taken = cpu->ext == instr->opcode.decoded.imm1;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}


/* "Positive" versions of branches */


int fn_B_i      (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7] += 2;

    cpu->r[7] = instr->opcode.decoded.imm0;

    return 9;
}

int fn_BOV_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* O = 1 */
    taken = cpu->O;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BC_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* C = 1 */
    taken = cpu->C;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BPL_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* S = 0 */
    taken = !cpu->S;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BEQ_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* Z = 1 */
    taken =  cpu->Z;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BLT_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* S ^ O = 1 */
    taken = cpu->S ^ cpu->O;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}
    

int fn_BLE_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* Z | S ^ O = 1 */
    taken = (cpu->Z | (cpu->S ^ cpu->O));

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BUSC_i   (const instr_t *instr, cpu_t *cpu)
{
    int taken;

    cpu->r[7] += 2;

    /* C ^ S = 1 */
    taken = cpu->C ^ cpu->S;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

/* "Negative" versions of branches. */

int fn_NOPP_i      (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7] += 2;

    (void)instr; /* unused */

    return 7;
}

int fn_BNOV_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* O = 0 */
    taken = !cpu->O;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BNC_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* C = 0 */
    taken = !cpu->C;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BMI_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* S = 1 */
    taken = cpu->S;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BNEQ_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* Z = 0 */
    taken = !cpu->Z;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BGE_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* S ^ O = 0 */
    taken = !(cpu->S ^ cpu->O);

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}
    

int fn_BGT_i    (const instr_t *instr, cpu_t *cpu)
{
    int taken;
    cpu->r[7] += 2;

    /* Z | (S ^ O) = 0 */
    taken = !(cpu->Z | (cpu->S ^ cpu->O));

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}

int fn_BESC_i   (const instr_t *instr, cpu_t *cpu)
{
    int taken;

    cpu->r[7] += 2;

    /* C ^ S = 0 */
    taken = cpu->C == cpu->S;

    if (taken) cpu->r[7] = instr->opcode.decoded.imm0;

    return 7 + (taken << 1);
}


int fn_SIN_i    (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    /* XXX: does SIN need to do anything?! */

    (void)instr; /* unused */
    cpu->intr = 0;

    return 6;
}

int fn_NOP_i    (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;

    (void)instr; /* unused */
    cpu->intr = 0;

    return 6;
}

int fn_J_i      (const instr_t *instr, cpu_t *cpu)
{
    int intr = instr->opcode.decoded.imm1;

    if (intr) cpu->I = intr & 1;

    cpu->r[7] = instr->opcode.decoded.imm0;

    return 12;
}

int fn_JSR_ir   (const instr_t *instr, cpu_t *cpu)
{
    int intr = instr->opcode.decoded.imm1;

    if (intr) cpu->I = intr & 1;

    cpu->r[instr->opcode.decoded.reg0] = cpu->r[7] + 3;
    cpu->r[7]                          = instr->opcode.decoded.imm0;

    return 12;
}

#define EXEC_SZOC(a,b,c,o,cpu)  \
    do {                                                \
        unsigned op1 = (a);                             \
        unsigned op2 = (b);                             \
        unsigned op3;                                   \
        cpu_word_t res;                                 \
        op3 = op2 o op1;                                \
        res = (cpu_word_t)op3;                          \
        (cpu)->S = !!(op3 & 0x8000);                    \
        (cpu)->C = !!(op3 & 0x10000);                   \
        (cpu)->O = !!((op2^op3) & ~(op1^op2) & 0x8000); \
        (cpu)->Z = !res;                                \
        (c) = res;                                      \
    } while(0);

#define EXEC_SZ(a,b,c,o,cpu)    \
    do {                                                \
        unsigned op1 = (a);                             \
        unsigned op2 = (b);                             \
        unsigned op3;                                   \
        cpu_word_t res;                                 \
        op3 = op2 o op1;                                \
        res = (cpu_word_t)op3;                          \
        (cpu)->S = !!(op3 & 0x8000);                    \
        (cpu)->Z = !res;                                \
        (c) = res;                                      \
    } while(0);


int fn_MVO_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    CPU_WR(cpu, &ws, addr, cpu->r[instr->opcode.decoded.reg0]);

    cpu->intr = 0;
    return 11 + ws;
}

int fn_MVI_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    cpu->r[instr->opcode.decoded.reg0] = CPU_RD(cpu, &ws, addr);

    return 11 + ws;
}


int fn_ADD_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    r0 = CPU_RD(cpu,&ws,addr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 10 + ws;
}
    
int fn_SUB_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    r0 = CPU_RD(cpu,&ws,addr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 10 + ws;
}

int fn_CMP_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;


    r0 = CPU_RD(cpu,&ws,addr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */

    return 10 + ws;
}

int fn_AND_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    r0 = CPU_RD(cpu,&ws,addr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;

    return 10 + ws;
}

int fn_XOR_dr   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = instr->opcode.decoded.imm0;
    cpu->r[7] += 2;

    r0 = CPU_RD(cpu,&ws,addr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;

    return 10 + ws;
}

#define DBDI(d,i) ((d)?(i)->opcode.decoded.imm1:(i)->opcode.decoded.imm0)

int fn_MVO_ir   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0;
    cpu->r[7] += 2 + cpu->D;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    if (cpu->D)
    {
        CPU_WR(cpu, &ws, instr->address+1, (r0 & 0xFF));
        CPU_WR(cpu, &ws, instr->address+2, (r0 >> 8));
    } else
    {
        CPU_WR(cpu, &ws, instr->address+1, r0);
    }

    cpu->intr = 0;
    return 8;
}

int fn_MVI_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    int d = cpu->D;

    cpu->r[7] += 2 + d;

    r0 = DBDI(d,instr);
    cpu->r[instr->opcode.decoded.reg0] = r0;
    
    return 8;
}

int fn_ADD_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int d = cpu->D;

    cpu->r[7] += 2 + cpu->D;

    r0 = DBDI(d,instr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_SUB_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int d = cpu->D;

    cpu->r[7] += 2 + cpu->D;

    r0 = DBDI(d,instr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_CMP_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int d = cpu->D;

    cpu->r[7] += 2 + cpu->D;

    r0 = DBDI(d,instr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 8;
}

int fn_AND_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int d = cpu->D;

    cpu->r[7] += 2 + cpu->D;

    r0 = DBDI(d,instr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_XOR_ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int d = cpu->D;

    cpu->r[7] += 2 + cpu->D;

    r0 = DBDI(d,instr);
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_MVO_Ir   (const instr_t *instr, cpu_t *cpu)
{
    int ws;
    cpu_word_t r0;
    cpu->r[7] += 2;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    CPU_WR(cpu, &ws, instr->address+1, r0);

    cpu->intr = 0;
    return 8;
}

int fn_MVI_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    cpu->r[instr->opcode.decoded.reg0] = r0;
    
    return 8;
}

int fn_ADD_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_SUB_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_CMP_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 8;
}

int fn_AND_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_XOR_Ir   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    cpu->r[7] += 2;

    r0 = instr->opcode.decoded.imm0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 8;
}

int fn_HLT      (const instr_t *instr, cpu_t *cpu)
{
    /* XXX: Uhm... NOP for now? */
    cpu->r[7]++;

    (void)instr; /* unused */

    printf("HALT! PC=%.4X Instr = %10lu MS = %10lu\n", 
            cpu->r[7], 
            (unsigned long)cpu->tot_instr, 
            (unsigned long)cpu->tot_cycle);
    /* exit(1); */


    return 100000000;
}

int fn_TCI      (const instr_t *instr, cpu_t *cpu)
{
    /* XXX: Uhm... NOP for now? */
    cpu->r[7]++;
    cpu->intr = 0;
    (void)instr; /* unused */

    return 4;
}

int fn_SDBD     (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    cpu->D = 2;
    cpu->intr = 0;
    (void)instr; /* unused */
    return 4;
}


int fn_EIS      (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    cpu->I = 1;
    cpu->intr = 0;
    (void)instr; /* unused */
    return 4;
}

int fn_DIS      (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    cpu->I = 0;
    cpu->intr = 0;
    (void)instr; /* unused */
    return 4;
}

int fn_CLRC     (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    cpu->C = 0;
    cpu->intr = 0;
    (void)instr; /* unused */
    return 4;
}

int fn_SETC     (const instr_t *instr, cpu_t *cpu)
{
    cpu->r[7]++;
    cpu->C = 1;
    cpu->intr = 0;
    (void)instr; /* unused */
    return 4;
}

int fn_INCR_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = 1;

    EXEC_SZ(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 6;
}

int fn_DECR_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu->r[7]++;

    r0 = 1;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,-,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 6;
}

int fn_COMR_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu->r[7]++;

    r0 = ~0;
    r1 = cpu->r[instr->opcode.decoded.reg0];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 6;
}

int fn_NEGR_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    cpu->r[7]++;

    r0 = -cpu->r[instr->opcode.decoded.reg0];

    cpu->S = !!(r0 & 0x8000);
    cpu->C = 0;
    cpu->O = 0;
    cpu->Z = !r0;

    cpu->r[instr->opcode.decoded.reg0] = r0;
    
    return 6;
}

int fn_ADCR_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->C;

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg0] = r2;
    
    return 6;
}

int fn_RSWD_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    cpu->S = !!(r0 & 0x80);
    cpu->Z = !!(r0 & 0x40);
    cpu->O = !!(r0 & 0x20);
    cpu->C = !!(r0 & 0x10);

    cpu->intr = 0;
    return 6;
}

int fn_GSWD_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    cpu->r[7]++;

    r0 = ((cpu->S << 7) | (cpu->Z << 6) | (cpu->O << 5) | (cpu->C << 4))&0xF0;
    r0 = r0 | (r0 << 8);

    cpu->r[instr->opcode.decoded.reg0] = r0;

    cpu->intr = 0;
    return 6;
}


int fn_MOV_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    cpu->r[reg1] = r0;
    cpu->r[7] = rp;

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !(r0);
    
    return 6 + (reg1 >> 2);
}

int fn_TST_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0, rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0] + (reg0 == 7);
    cpu->r[7] = rp;

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !(r0);
    
    return 6 + (reg1 >> 2);
}

int fn_ADD_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    r1 = cpu->r[reg1];
    cpu->r[7] = rp;

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_SUB_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    r1 = cpu->r[reg1];
    cpu->r[7] = rp;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_CMP_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    r1 = cpu->r[reg1];
    cpu->r[7] = rp;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 6;
}

int fn_AND_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    r1 = cpu->r[reg1];
    cpu->r[7] = rp;

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_XOR_rr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2,rp;
    int reg0 = instr->opcode.decoded.reg0;
    int reg1 = instr->opcode.decoded.reg1;

    rp = cpu->r[7] + 1;
    r0 = cpu->r[reg0];
    r1 = cpu->r[reg1];
    cpu->r[7] = rp;

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_MOV_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    cpu->r[reg1] = r0;
    cpu->r[7] = r0;

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !(r0);
    
    return 6 + (reg1 >> 2);
}

int fn_ADD_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    r1 = cpu->r[reg1];
    cpu->r[7] = r0;

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_SUB_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    r1 = cpu->r[reg1];
    cpu->r[7] = r0;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_CMP_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    r1 = cpu->r[reg1];
    cpu->r[7] = r0;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 6;
}

int fn_AND_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    r1 = cpu->r[reg1];
    cpu->r[7] = r0;

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_XOR_pr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    int reg1 = instr->opcode.decoded.reg1;

    r0 = cpu->r[7] + 1;
    r1 = cpu->r[reg1];
    cpu->r[7] = r0;

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[reg1] = r2;
    
    return 6;
}

int fn_MOV_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    int reg0 = instr->opcode.decoded.reg0;

    r0 = cpu->r[reg0];
    cpu->r[7] = r0;

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !(r0);
    
    return 7;
}

int fn_ADD_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->r[7] + 1;

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[7] = r2;
    
    return 6;
}

int fn_SUB_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->r[7] + 1;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[7] = r2;
    
    return 6;
}

int fn_CMP_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    
    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->r[7] + 1;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 6;
}

int fn_AND_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->r[7] + 1;

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[7] = r2;
    
    return 6;
}

int fn_XOR_rp   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;

    r0 = cpu->r[instr->opcode.decoded.reg0];
    r1 = cpu->r[7] + 1;

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[7] = r2;
    
    return 6;
}


int fn_SWAP1_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (0xFF & (r0 >> 8)) | ((0xFF & r0) << 8);

    cpu->Z = !r0;
    cpu->S = !!(r0 & 0x80);

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_SLL1_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = r0 << 1;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_SLLC1_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = r0 << 1;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;
    cpu->C = !!(r0 & 0x8000);

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_RLC1_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 << 1) | cpu->C;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;
    cpu->C = !!(r0 & 0x8000);

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}


int fn_SLR1_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = 0x7FFF & (r0 >> 1);

    cpu->S = 0;
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_RRC1_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (0x7FFF & (r0 >> 1)) | (cpu->C << 15);

    cpu->S = 0;
    cpu->Z = !r1;
    cpu->C = r0 & 1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_SAR1_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 >> 1) | (r0 & 0x8000);

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_SARC1_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 >> 1) | (r0 & 0x8000);

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !r1;
    cpu->C = r0 & 1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 6;
}

int fn_SWAP2_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    cpu->S = !!(r0 & 0x80);
    cpu->Z = !r0;
    cpu->intr = 0;
    
    return 8;
}

int fn_SLL2_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = r0 << 2;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_SLLC2_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = r0 << 2;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;
    cpu->C = !!(r0 & 0x8000);
    cpu->O = !!(r0 & 0x4000);

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_RLC2_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 << 2) | (cpu->C << 1) | cpu->O;

    cpu->S = !!(r1 & 0x8000);
    cpu->Z = !r1;
    cpu->C = !!(r0 & 0x8000);
    cpu->O = !!(r0 & 0x4000);

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_SLR2_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = 0x3FFF & (r0 >> 2);

    cpu->S = 0;
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_RRC2_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (0x3FFF & (r0 >> 2)) | (cpu->C << 14) | (cpu->O << 15);

    cpu->S = 0;
    cpu->Z = !r1;
    cpu->C = r0 & 1;
    cpu->C = r0 & 2;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_SAR2_r   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 >> 1) | (r0 & 0x8000);
    r1 = (r1 >> 1) | (r0 & 0x8000);

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !r1;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}

int fn_SARC2_r  (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1;
    cpu->r[7]++;

    r0 = cpu->r[instr->opcode.decoded.reg0];

    r1 = (r0 >> 1) | (r0 & 0x8000);
    r1 = (r1 >> 1) | (r0 & 0x8000);

    cpu->S = !!(r0 & 0x8000);
    cpu->Z = !r1;
    cpu->C = r0 & 1;
    cpu->O = r0 & 2;

    cpu->r[instr->opcode.decoded.reg0] = r1;
    cpu->intr = 0;
    
    return 8;
}


int fn_MVO_mr   (const instr_t *instr, cpu_t *cpu)
{
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t data = cpu->r[instr->opcode.decoded.reg1];

    cpu->r[7]++;

    if (d)
    {
        CPU_WR(cpu, &ws0, addr, data & 0xFF);
        CPU_WR(cpu, &ws1, addr, (data >> 8) & 0xFF);
    } else
    {
        CPU_WR(cpu, &ws0, addr, data);
    }

    cpu->intr = 0;
    return 9 + ws0 + ws1;
}
    
int fn_MVI_mr   (const instr_t *instr, cpu_t *cpu)
{
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t r0;

    cpu->r[7]++;

    r0 = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    cpu->r[instr->opcode.decoded.reg1] = r0;

    return 8 + ws0 + ws1;
}

int fn_ADD_mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 8 + ws0 + ws1;
}

int fn_SUB_mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 8 + ws0 + ws1;
}

int fn_CMP_mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2;   /* r2's value is discarded */
    
    return 8 + ws0 + ws1;
}

int fn_AND_mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 8 + ws0 + ws1;
}

int fn_XOR_mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r0  = CPU_RD(cpu, &ws0, addr);
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8;
    } 

    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 8 + ws0 + ws1;
}


int fn_MVO_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t data = cpu->r[instr->opcode.decoded.reg1];
    int ws0 = 0, ws1 = 0, d = cpu->D;

    cpu->r[7]++;

    if (d)
    {
        CPU_WR(cpu, &ws0, addr, data & 0xFF); addr++;
        CPU_WR(cpu, &ws1, addr, (data >> 8) & 0xFF); addr++;
    } else
    {
        CPU_WR(cpu, &ws0, addr, data); addr++;
    }

    cpu->r[instr->opcode.decoded.reg0] = addr;
    cpu->intr = 0;
    return 9 + ws0 + ws1;
}
    
int fn_MVI_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t r0 = 0;
    int ws0 = 0, ws1 = 0, d = cpu->D;

    cpu->r[7]++;

    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    cpu->r[instr->opcode.decoded.reg0] = addr;
    cpu->r[instr->opcode.decoded.reg1] = r0;
    return 11 + ws0 + ws1;
}

int fn_ADD_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0 + ws1;
}

int fn_SUB_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0 + ws1;
}

int fn_CMP_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2;   /* r2's value is discarded */

    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0 + ws1;
}

int fn_AND_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0 + ws1;
}

int fn_XOR_Mr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0, ws1 = 0, d = cpu->D;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;
    if (d)
    {
        r0 &= 0xFF;
        r0 |= CPU_RD(cpu, &ws1, addr) << 8; addr++;
    }

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0 + ws1;
}


int fn_MVO_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t data = cpu->r[instr->opcode.decoded.reg1];
    int ws0 = 0;

    cpu->r[7]++;

    CPU_WR(cpu, &ws0, addr, data); addr++;

    cpu->r[instr->opcode.decoded.reg0] = addr;
    cpu->intr = 0;
    return 9 + ws0;
}
    
int fn_MVI_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t r0 = 0;
    int ws0 = 0;

    cpu->r[7]++;

    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    cpu->r[instr->opcode.decoded.reg0] = addr;
    cpu->r[instr->opcode.decoded.reg1] = r0;
    return 11 + ws0;
}

int fn_ADD_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0;
}

int fn_SUB_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0;
}

int fn_CMP_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2;   /* r2's value is discarded */

    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0;
}

int fn_AND_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0;
}

int fn_XOR_Nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); addr++;

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    cpu->r[instr->opcode.decoded.reg0] = addr;
    return 11 + ws0;
}

int fn_MVO_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t data = cpu->r[instr->opcode.decoded.reg1];
    int ws0 = 0;

    cpu->r[7]++;

    CPU_WR(cpu, &ws0, addr, data); 

    cpu->intr = 0;
    return 9 + ws0;
}
    
int fn_MVI_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    cpu_word_t r0 = 0;
    int ws0 = 0;

    cpu->r[7]++;

    r0 = CPU_RD(cpu, &ws0, addr); 

    cpu->r[instr->opcode.decoded.reg1] = r0;
    return 11 + ws0;
}

int fn_ADD_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); 

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    return 11 + ws0;
}

int fn_SUB_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); 

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    return 11 + ws0;
}

int fn_CMP_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); 

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2;   /* r2's value is discarded */

    return 11 + ws0;
}

int fn_AND_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); 

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    return 11 + ws0;
}

int fn_XOR_nr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;

    r1 = cpu->r[instr->opcode.decoded.reg1];
    r0 = CPU_RD(cpu, &ws0, addr); 

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    return 11 + ws0;
}

    
int fn_MVI_Sr   (const instr_t *instr, cpu_t *cpu)
{
    int ws0 = 0, ws1 = 0;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0] - 1;
    cpu_word_t r0 = 0;

    cpu->r[7]++;

    r0  = CPU_RD(cpu, &ws0, addr);
    cpu->r[instr->opcode.decoded.reg0] = addr;
    cpu->r[instr->opcode.decoded.reg1] = r0;

    return 11 + ws0 + ws1;
}

int fn_ADD_Sr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;


    r0  = CPU_RD(cpu, &ws0, addr - 1);
    cpu->r[instr->opcode.decoded.reg0]--;
    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZOC(r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 11 + ws0;
}

int fn_SUB_Sr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;


    r0  = CPU_RD(cpu, &ws0, addr - 1);
    cpu->r[instr->opcode.decoded.reg0]--;
    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 11 + ws0;
}

int fn_CMP_Sr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;


    r0  = CPU_RD(cpu, &ws0, addr - 1);
    cpu->r[instr->opcode.decoded.reg0]--;
    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZOC(-r0,r1,r2,+,cpu);

    (void)r2; /* unused */
    
    return 11 + ws0;
}

int fn_AND_Sr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;


    r0  = CPU_RD(cpu, &ws0, addr - 1);
    cpu->r[instr->opcode.decoded.reg0]--;
    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZ(r0,r1,r2,&,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 11 + ws0;
}

int fn_XOR_Sr   (const instr_t *instr, cpu_t *cpu)
{
    cpu_word_t r0,r1,r2;
    cpu_word_t addr = cpu->r[instr->opcode.decoded.reg0];
    int ws0 = 0;
    cpu->r[7]++;


    r0  = CPU_RD(cpu, &ws0, addr - 1);
    cpu->r[instr->opcode.decoded.reg0]--;
    r1 = cpu->r[instr->opcode.decoded.reg1];

    EXEC_SZ(r0,r1,r2,^,cpu);

    cpu->r[instr->opcode.decoded.reg1] = r2;
    
    return 11 + ws0;
}


/*
 * ============================================================================
 *                      Copyright (c) 1998, Joseph Zbiciak.
 * ============================================================================
 */