CINESTATE opINP_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opINP_A_AA (%02x) */\n", cur_tabs, opcode);
  if (comments) {
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * bottom 4 bits of opcode are the position of the bit we want;\n");
  fprintf(stdout, "%s%s", cur_tabs, " * obtain input value, shift over that no, and truncate to last bit.\n");
  fprintf(stdout, "%s%s", cur_tabs, " * NOTE: Masking 0x07 does interesting things on Sundance and\n");
  fprintf(stdout, "%s%s", cur_tabs, " * others, but masking 0x0F makes RipOff and others actually work :)\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  }
  fprintf(stdout, "%scmp_new = (CCPU_READPORT (CCPU_PORT_IOINPUTS) >> (0x%02x & 0x0F)) & 0x01;\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A; /* save old accB */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = cmp_new; /* load new accB; zero other bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opINP_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opINP_B_AA (%02x) */\n", cur_tabs, opcode);
  if (comments) {
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * bottom 3 bits of opcode are the position of the bit we want;\n");
  fprintf(stdout, "%s%s", cur_tabs, " * obtain Switches value, shift over that no, and truncate to last bit.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  }
  fprintf(stdout, "%scmp_new = (CCPU_READPORT (CCPU_PORT_IOSWITCHES) >> 0x%01x) & 0x01;\n", cur_tabs, (opcode & 0x07));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* save old accB */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B = cmp_new; /* load new accB; zero other bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opOUTsnd_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTsnd_A (%02x) */\n", cur_tabs, opcode);
  if (register_A != 0xDEADBEEFUL) {
    if (!(register_A & 0x01)) {
      fprintf(stdout, "%sCCPU_WRITEPORT (CCPU_PORT_IOOUTPUTS, CCPU_READPORT (CCPU_PORT_IOOUTPUTS) | 0x%04x);\n", cur_tabs, (1 << (opcode & 0x07)));
    } else {
      fprintf(stdout, "%sCCPU_WRITEPORT (CCPU_PORT_IOOUTPUTS, CCPU_READPORT (CCPU_PORT_IOOUTPUTS) & ~(0x%04x));\n", cur_tabs, (1 << (opcode & 0x07)));
    }
  } else {
    fprintf(stdout, "%s%s", cur_tabs, "if (!(register_A & 0x01))\n");
    fprintf(stdout, "%s	CCPU_WRITEPORT (CCPU_PORT_IOOUTPUTS, CCPU_READPORT (CCPU_PORT_IOOUTPUTS) | 0x%04x);\n", cur_tabs, (1 << (opcode & 0x07)));
    fprintf(stdout, "%s%s", cur_tabs, "else\n");
    fprintf(stdout, "%s	CCPU_WRITEPORT (CCPU_PORT_IOOUTPUTS, CCPU_READPORT (CCPU_PORT_IOOUTPUTS) & ~(0x%04x));\n", cur_tabs, (1 << (opcode & 0x07)));
    fprintf(stdout, "%s%s", cur_tabs, "\n");
  }
  if ((opcode & 0x07) == 0x05) {
    fprintf(stdout, "%s%s", cur_tabs, "/* REQUIRED: reset coin counter */\n");
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opOUTbi_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTbi_A_A (%02x) */\n", cur_tabs, opcode);

  if ((opcode & 0x07) != 6) {
    opOUTsnd_A (opcode); /* Macro expand */
  }

  if (register_A != 0xDEADBEEFUL) {
    fprintf(stdout, "%svgColour = 0x%02x;\n", cur_tabs, (register_A & 0x01 ? 0x0f: 0x07));
  } else {
    fprintf(stdout, "%s%s", cur_tabs, "vgColour = register_A & 0x01 ? 0x0f: 0x07;\n");
  }

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opOUT16_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUT16_A_A (%02x) */\n", cur_tabs, opcode);

  if ((opcode & 0x07) != 6)
    return opOUTsnd_A (opcode);

  fprintf(stdout, "%s%s", cur_tabs, "if ((register_A & 0x1) != 1)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		vgColour = FromX & 0x0F;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (!vgColour)\n");
  fprintf(stdout, "%s%s", cur_tabs, "			vgColour = 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opOUT64_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUT64_A_A (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opOUTWW_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTWW_A_A (%02x) */\n", cur_tabs, opcode);

  if ((opcode & 0x07) != 6)
    return opOUTsnd_A (opcode);

  fprintf(stdout, "%s%s", cur_tabs, "if ((register_A & 0x1) == 1)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		CINEWORD temp_word = ~FromX & 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (!temp_word) /* black */\n");
  fprintf(stdout, "%s%s", cur_tabs, "			vgColour = 0;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		else\n");
  fprintf(stdout, "%s%s", cur_tabs, "		{ /* non-black */\n");
  fprintf(stdout, "%s%s", cur_tabs, "					if (temp_word & 0x0888)\n");
  fprintf(stdout, "%s%s", cur_tabs, "						 /* bright */\n");
  fprintf(stdout, "%s%s", cur_tabs, "						vgColour = ((temp_word >> 1) & 0x04) | ((temp_word >> 6) & 0x02) | ((temp_word >> 11) & 0x01) | 0x08;\n");
  fprintf(stdout, "%s%s", cur_tabs, "					else if (temp_word & 0x0444)\n");
  fprintf(stdout, "%s%s", cur_tabs, "						 /* dim bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "						vgColour = (temp_word & 0x04) | ((temp_word >> 5) & 0x02) | ((temp_word >> 10) & 0x01);\n");
  fprintf(stdout, "%s%s", cur_tabs, "		}\n");
  fprintf(stdout, "%s%s", cur_tabs, "} /* colour change? == 1 */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opOUTsnd_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTsnd_B (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opOUTbi_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTbi_B_BB (%02x) */\n", cur_tabs, opcode);

  if ((opcode & 0x07) - 0x06)
    return opOUTsnd_B (opcode);

  fprintf(stdout, "%s%s", cur_tabs, "vgColour = ((register_B & 0x01) << 3) | 0x07;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opOUT16_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUT16_B_BB (%02x) */\n", cur_tabs, opcode);

  if ((opcode & 0x07) - 0x06)
    return opOUTsnd_B (opcode);

  fprintf(stdout, "%s%s", cur_tabs, "if ((register_B & 0xFF) != 1)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		vgColour = FromX & 0x0F;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (!vgColour)\n");
  fprintf(stdout, "%s%s", cur_tabs, "			vgColour = 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opOUT64_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUT64_B_BB (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opOUTWW_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opOUTWW_B_BB (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opLDAimm_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAimm_A_AA (%02x) */\n", cur_tabs, opcode);
  if (opcode == 0 /* CLR */) {
    fprintf(stdout, "%sregister_A = 0;\n", cur_tabs);
    register_A = 0;
  } else if (ImmOpd != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_A = 0x%04x;\n", cur_tabs, register_A = ImmOpd);
  } else {
  fprintf(stdout, "%sCINEWORD temp_word = 0x%02x & 0x0F; /* pick up immediate value */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "temp_word <<= 8; /* LDAimm is the HIGH nibble!*/\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word; /* set new comparison flag */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s; /* clear carry since top bit already 0 */\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A; /* step back cmp flag */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = temp_word; /* set the register */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA; /* swap state and end opcode */\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLDAimm_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAimm_B_AA (%02x) */\n", cur_tabs, opcode);
  if (opcode == 0 /* CLR */) {
    fprintf(stdout, "%sregister_B = 0;\n", cur_tabs);
    register_B = 0;
  } else if (ImmOpd != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_B = 0x%04x;\n", cur_tabs, register_B = ImmOpd);
  } else {
  fprintf(stdout, "%sCINEWORD temp_word = 0x%02x & 0x0F; /* pick up immediate value */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "temp_word <<= 8; /* LDAimm is the HIGH nibble!*/\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word; /* set new comparison flag */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* step back cmp flag */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B = temp_word; /* set the register */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLDAdir_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAdir_A_AA (%02x) */\n", cur_tabs, opcode);

  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = flag_C = acc_a0 = register_A; /* store old acc */\n");
  if (register_P != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_A = cmp_new = ram[register_I = 0x%04x]; /* set I register */\n", cur_tabs, register_I = (register_P << 4) + (opcode & 0x0f));
  } else {
    fprintf(stdout, "%sregister_A = cmp_new = ram[register_I = (register_P << 4) + 0x%02x]; /* set I register */\n", cur_tabs, (opcode & 0x0f));
    register_I = 0xDEADBEEFUL;
  }
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLDAdir_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAdir_B_AA (%02x) */\n", cur_tabs, opcode);

/* remember to finish compressing the source code */

  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* snag imm value */\n", cur_tabs, opcode & 0x0F);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = (register_P << 4) + temp_byte; /* set I register */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I]; /* new acc value */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s; /* back up bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* store old acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B = cmp_new; /* store new acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLDAirg_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAirg_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I];\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = cmp_new;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLDAirg_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDAirg_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I];\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B = cmp_new;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opADDimm_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDimm_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sregister_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x%04x))) & 0xFFF; /* add values, save carry */\n", cur_tabs, (opcode & 0x0f));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opADDimm_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDimm_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* store old acc for later */\n");
  fprintf(stdout, "%sregister_B = (flag_C = (register_B + (cmp_new = 0x%04x))) & 0xFFF; /* add values */\n", cur_tabs, (opcode & 0x0F));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opADDimmX_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDimmX_A_AA (%02x) */\n", cur_tabs, opcode);
  if (ImmOpd == 0xDEADBEEFUL) {
    ImmOpd = rom[register_PC+1]; /* Why wasn't this picked up in the opcode decoding? */
  }
  if (register_A != 0xDEADBEEFUL) {
    if (((ImmOpd + register_A) >> 12) != 0) {
      fprintf(stdout, "%sregister_A = (flag_C = (cmp_old = acc_a0 = 0x%04x)) & 0xFFF;\n", cur_tabs, register_A = (ImmOpd+register_A));
      register_A &= 0xFFF;
    } else {
      fprintf(stdout, "%sregister_A = flag_C = cmp_old = acc_a0 = 0x%04x;\n", cur_tabs, register_A = (ImmOpd+register_A));
    }
  } else {
    fprintf(stdout, "%sregister_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x%04x))) & 0xFFF; /* add values */\n", cur_tabs, ImmOpd);
    register_A = 0xDEADBEEFUL;                        /* IS THIS BRACKETING CORRECT? */
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opADDimmX_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDimmX_B_AA (%02x) */\n", cur_tabs, opcode);

  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A"));

  if (ImmOpd == 0xDEADBEEFUL) {
    ImmOpd = rom[register_PC+1]; /* Why wasn't this picked up in the opcode decoding? */
  }
  if (register_A != 0xDEADBEEFUL) {
    if (((ImmOpd + register_A) >> 12) != 0) {
      fprintf(stdout, "%sregister_B = (flag_C = (cmp_old = 0x%04x)) & 0xFFF /* carry */;\n", cur_tabs, register_A = (ImmOpd+register_A));
      register_A &= 0xFFF;
    } else {
      fprintf(stdout, "%sregister_B = flag_C = cmp_old = 0x%04x; /* No carry */\n", cur_tabs, register_A = (ImmOpd+register_A));
    }
  } else {
    fprintf(stdout, "%sregister_B = (flag_C = ((cmp_old = register_B) + (cmp_new = 0x%04x))) & 0xFFF; /* add values */\n", cur_tabs, ImmOpd);
                                              /* Is this bracketing correct? */
    register_B = 0xDEADBEEFUL;
  }

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opADDdir_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDdir_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = acc_a0 = register_A; /* store old acc value */\n");
  if (register_P != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_A = (flag_C = (register_A + (cmp_new = ram[register_I = 0x%04x]))) & 0xFFF; /* do acc operation */\n", cur_tabs, register_I = (register_P << 4) + (opcode & 0x0F));
  } else {
    fprintf(stdout, "%sregister_A = (flag_C = (register_A + (cmp_new = ram[register_I = (register_P << 4) + 0x%01x]))) & 0xFFF; /* do acc operation */\n", cur_tabs, (opcode & 0x0F));
    register_I = 0xDEADBEEFUL;
  }
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opADDdir_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opADDdir_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* fetch imm value */\n", cur_tabs, opcode & 0x0F);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = (register_P << 4) + temp_byte; /* set regI addr */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I]; /* fetch imm real value */\n");
  fprintf(stdout, "%s%s; /* store bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* store old acc value */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B += cmp_new; /* do acc operation */\n");
  fprintf(stdout, "%s%s; /* store carry and extra */\n", cur_tabs, SETFC ("register_B"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opAWDirg_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opAWDirg_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = acc_a0 = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opAWDirg_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opAWDirg_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I];\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B += cmp_new;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_B"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBimm_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBimm_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " *	SUBtractions are negate-and-add instructions of the CCPU; what\n");
  fprintf(stdout, "%s%s", cur_tabs, " *	a pain in the ass.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%sCINEWORD temp_word = 0x%02x & 0x0F;\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word = (temp_word ^ 0xFFF) + 1; /* ones compliment */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A += temp_word; /* add */\n");
  fprintf(stdout, "%s%s; /* pick up top bits */\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= 0x0FFF; /* mask final regA value */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBimm_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBimm_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * SUBtractions are negate-and-add instructions of the CCPU; what\n");
  fprintf(stdout, "%s%s", cur_tabs, " * a pain in the ass.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%sregister_B = (flag_C = (register_B + ((cmp_new = 0x%04x) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */\n", cur_tabs, (opcode & 0x0F));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBimmX_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBimmX_A_AA (%02x) */\n", cur_tabs, opcode);
/* Question: is this the byte FOLLOWING the instruction? */
  if (ImmOpd == 0xDEADBEEFUL) {
    ImmOpd = rom[register_PC+1]; /* Why wasn't this picked up in the opcode decoding? */
  }

  fprintf(stdout, "%scmp_old = acc_a0 = register_A; /* back up regA */\n", cur_tabs);
  fprintf(stdout, "%sregister_A = (flag_C = (register_A + (((cmp_new = 0x%02x) ^ 0xFFF) + 1))) & 0xFFF; /* add */\n", cur_tabs, ImmOpd);

  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBimmX_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBimmX_B_AA (%02x) */\n", cur_tabs, opcode);
  if (ImmOpd == 0xDEADBEEFUL) {
    ImmOpd = rom[register_PC+1]; /* Why wasn't this picked up in the opcode decoding? */
  }
  fprintf(stdout, "%sacc_a0 = register_A;\n", cur_tabs);
  fprintf(stdout, "%sregister_B = (flag_C = ((cmp_old = register_B) + (((cmp_new = 0x%02x) ^ 0xFFF) + 1))) & 0xFFF; /* add */\n", cur_tabs, ImmOpd);

  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBdir_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBdir_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = acc_a0 = register_A;\n");

  if (register_P != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x%04x]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */\n", cur_tabs, register_I = (register_P << 4) + (opcode & 0x0F));
  } else {
    fprintf(stdout, "%sregister_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x%01x]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */\n", cur_tabs, (opcode & 0x0F));
    register_I = 0xDEADBEEFUL;
  }
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBdir_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBdir_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word;\n");
  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* fetch imm value */\n", cur_tabs, opcode & 0x0F);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = (register_P << 4) + temp_byte; /* set regI addr */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I];\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word = (cmp_new ^ 0xFFF) + 1; /* ones compliment */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B += temp_word; /* add */\n");
  fprintf(stdout, "%s%s; /* pick up top bits */\n", cur_tabs, SETFC ("register_B"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF; /* mask final regA value */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBirg_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBirg_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* sub [i] */\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = acc_a0 = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = (flag_C = (register_A + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opSUBirg_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSUBirg_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* sub [i] */\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B = (flag_C = (register_B + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opCMPdir_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opCMPdir_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * compare direct mode; don't modify regs, just set carry flag or not.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  if (register_P == 0xDEADBEEFUL) {
    fprintf(stdout, "%scmp_new = ram[register_I = (register_P << 4) + 0x%01x]; /* build real addr */\n", cur_tabs, (opcode & 0x0f));
  } else {
    fprintf(stdout, "%scmp_new = ram[register_I = 0x%04x];\n", cur_tabs, register_I = ((register_P << 4) + (opcode & 0x0f)));
  }
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = acc_a0 = register_A; /* backup old acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "flag_C = ((cmp_new ^ 0xFFF) + 1 + register_A);\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opCMPdir_B_AA (int opcode)
{
  internal_test(opcode);
  /* SEE ABOVE */
  fprintf(stdout, "%s/* opCMPdir_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word;\n");
  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* obtain relative addr */\n", cur_tabs, opcode & 0x0F);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = (register_P << 4) + temp_byte; /* build real addr */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word = ram[register_I];\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word; /* new acc value */\n");
  fprintf(stdout, "%s%s; /* backup bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* backup old acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word = (temp_word ^ 0xFFF) + 1; /* ones compliment */\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_B;\n");
  fprintf(stdout, "%s%s; /* pick up top bits */\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opANDirg_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opANDirg_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I]; /* new acc value */\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= cmp_new;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opANDirg_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opANDirg_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = ram[register_I]; /* new acc value */\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= cmp_new;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opLDJimm_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDJimm_A_A (%02x) */\n", cur_tabs, opcode);

  if (ImmOpd == 0xDEADBEEFUL) {
    CINEWORD temp_byte = rom[register_PC+1];
    temp_byte = ((temp_byte << 4) | (temp_byte >> 4)) & 0xFF;
    ImmOpd = (opcode & 0x0F) | (temp_byte << 4);
  }
  fprintf(stdout, "%sregister_J = 0x%04x;\n", cur_tabs, register_J = ImmOpd);

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opLDJimm_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDJimm_B_BB (%02x) */\n", cur_tabs, opcode);

  if (ImmOpd == 0xDEADBEEFUL) {
    CINEWORD temp_byte = rom[register_PC+1];
    temp_byte = ((temp_byte << 4) | (temp_byte >> 4)) & 0xFF;
    ImmOpd = (opcode & 0x0F) | (temp_byte << 4);
  }
  fprintf(stdout, "%sregister_J = 0x%04x;\n", cur_tabs, register_J = ImmOpd);

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opLDJirg_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDJirg_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* load J reg from value at last dir addr */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_J = ram[register_I];\n");
  register_J = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opLDJirg_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDJirg_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "register_J = ram[register_I];\n");
  register_J = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opLDPimm_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDPimm_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* load page register from immediate */\n");
  if (ImmOpd != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_P = 0x%04x; /* set page register */\n", cur_tabs, ImmOpd);
    register_P = ImmOpd;
  } else {
    fprintf(stdout, "%sregister_P = 0x%02x; /* set page register */\n", opcode & 0x0F);
    /* ERROR - can't see why it would ever get here */
    exit(1);
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opLDPimm_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDPimm_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* load page register from immediate */\n");
  fprintf(stdout, "%sregister_P = 0x%02x; /* set page register */\n", cur_tabs, opcode & 0x0F);
  register_P = 0xDEADBEEFUL; /* FOR NOW - CAN OPTIMISE */
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opLDIdir_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDIdir_A_A (%02x) */\n", cur_tabs, opcode);
  if (register_P != 0xDEADBEEFUL) {
    fprintf(stdout, "%sregister_I = ram[0x%04x] & 0xFF; /* set/mask new register_I */\n", cur_tabs, (register_P << 4) + (opcode & 0x0f));
    register_I = 0xDEADBEEFUL; /* since we don't know what's in ram */
  } else {
  fprintf(stdout, "%s%s", cur_tabs, "/* load regI directly .. */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEBYTE temp_byte = (register_P << 4) + /* get ram page ... */\n");
  fprintf(stdout, "%s         (0x%02x & 0x0F); /* and imm half of ram addr.. */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = ram[temp_byte] & 0xFF; /* set/mask new register_I */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_I = 0xDEADBEEFUL;
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opLDIdir_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLDIdir_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEBYTE temp_byte = (register_P << 4) + /* get ram page ... */\n");
  fprintf(stdout, "%s         (0x%02x & 0x0F); /* and imm half of ram addr.. */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = ram[temp_byte] & 0xFF; /* set/mask new register_I */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_I = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opSTAdir_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSTAdir_A_A (%02x) */\n", cur_tabs, opcode);

  if (register_P != 0xDEADBEEFUL) {
    register_I = (register_P << 4) + (opcode & 0x0F); /* snag imm value */;
  } else {
    fprintf(stdout, "%sregister_I = (register_P << 4) + 0x%1x; /* set I register */\n", cur_tabs, (opcode & 0x0F));
  }

  if (register_I != 0xDEADBEEFUL) {
    fprintf(stdout, "%sram[0x%02x] = ", cur_tabs, register_I);
  } else {
    fprintf(stdout, "%sram[register_I] = ", cur_tabs);
  }

  if (register_A != 0xDEADBEEFUL) {
    fprintf(stdout, "0x%04x; /* store acc to RAM */\n", register_A);
  } else {
    fprintf(stdout, "register_A; /* store acc to RAM */\n");
  }

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opSTAdir_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSTAdir_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* snag imm value */\n", cur_tabs, (opcode & 0x0F));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_I = (register_P << 4) + temp_byte; /* set I register */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "ram[register_I] = register_B; /* store acc to RAM */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opSTAirg_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSTAirg_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * STA into address specified in regI. Nice and easy :)\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "ram[register_I] = register_A; /* store acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opSTAirg_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opSTAirg_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "ram[register_I] = register_B; /* store acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}


CINESTATE opXLT_A_AA (int opcode)
{
  internal_test(opcode);
  /* We should check the next opcode to see that it is a NOP.
     If not, need to look at this more closely */

  fprintf(stdout, "%s/* opXLT_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * XLT is weird; it loads the current accumulator with the bytevalue\n");
  fprintf(stdout, "%s%s", cur_tabs, " * at ROM location pointed to by the accumulator; this allows the\n");
  fprintf(stdout, "%s%s", cur_tabs, " * program to read the program itself..\n");
  fprintf(stdout, "%s%s", cur_tabs, " *		NOTE! Next opcode is *IGNORED!* because of a twisted side-effect\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");

  fprintf(stdout, "%sregister_A = rom[(register_PC & 0xF000) | register_A]; /* new acc value */\n", cur_tabs);
  fprintf(stdout, "%sregister_PC = 0x%04x; /* bump PC twice because XLT is fucked up */\n", cur_tabs, register_PC+2);

  register_A = 0xDEADBEEFUL; /* FOR NOW, UNLESS BETTER OPTIMISED */
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
  fprintf(stdout, "%s%s", cur_tabs, "break;  /* Jump over next instruction - could be better optimised */\n");
}

CINESTATE opXLT_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opXLT_B_AA (%02x) */\n", cur_tabs, opcode);

  fprintf(stdout, "%s%s", cur_tabs, "flag_C = acc_a0 = register_A; /* back up acc */\n", cur_tabs);
  fprintf(stdout, "%sregister_B = cmp_new = rom[(register_PC & 0xF000) | (cmp_old = register_B)]; /* new acc value */\n", cur_tabs);
  fprintf(stdout, "%sregister_PC = 0x%04x; /* bump PC twice because XLT is fucked up */\n", cur_tabs, register_PC+2);

  register_B = 0xDEADBEEFUL; /* FOR NOW, UNLESS BETTER OPTIMISED */
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opMULirg_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opMULirg_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sCINEBYTE temp_byte = 0x%02x; /* (for ease and speed) */\n", cur_tabs, opcode & 0xFF);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = ram[register_I]; /* pick up ram value */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word <<= 4; /* shift into ADD position */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 4; /* get sign bit 15 */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B |= (register_A >> 8); /* bring in A high nibble */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A = ((register_A & 0xFF) << 8) | /* shift over 8 bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "          temp_byte; /* pick up opcode */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (register_A & 0x100)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{					 /* 1bit shifted out? */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A = (register_A >> 8) |\n");
  fprintf(stdout, "%s%s", cur_tabs, "		             ((register_B & 0xFF) << 8);\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		%s; /* store bit0 */\n", cur_tabs, SETA0 ("register_A & 0xFF"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A >>= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		register_B = %s;\n", cur_tabs, SAR("register_B","4"));
  fprintf(stdout, "%s%s", cur_tabs, "		cmp_old = register_B & 0x0F;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		register_B = %s;\n", cur_tabs, SAR("register_B","1"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_B &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_B += cmp_new;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		%s;\n", cur_tabs, SETFC ("register_B"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_B &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "else\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A = (register_A >> 8) | /* Bhigh | Alow */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		             ((register_B & 0xFF) << 8);\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word = register_A & 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		%s; /* store bit0 */\n", cur_tabs, SETA0 ("temp_word & 0xFF"));
  fprintf(stdout, "%s%s", cur_tabs, "		cmp_old = temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word += cmp_new;\n");
  fprintf(stdout, "%s		%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A >>= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s		register_B = %s;\n", cur_tabs, SAR("register_B","5"));
  fprintf(stdout, "%s%s", cur_tabs, "		register_B &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opMULirg_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opMULirg_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = ram[register_I];\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A & 0xFF"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 4;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%sregister_B = %s;\n", cur_tabs, SAR("register_B","5"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (register_A & 0x01)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_B += temp_word;\n");
  fprintf(stdout, "%s		%s;\n", cur_tabs, SETFC ("register_B"));
  fprintf(stdout, "%s%s", cur_tabs, "		register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "else\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word += register_B;\n");
  fprintf(stdout, "%s		%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}


CINESTATE opLSRe_A_AA (int opcode)
{
  internal_test(opcode);

  /* IS THIS CODE RIGHT?  What is this BEB stuff about? */

  fprintf(stdout, "%s/* opLSRe_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * EB; right shift pure; fill new bit with zero.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0BEB;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_A;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A >>= 1;\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSRe_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSRe_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0BEB;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_B;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B >>= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSRf_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSRf_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLSRf 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSRf_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSRf_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLSRf 2\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLe_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLe_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * EC; left shift pure; fill new bit with zero *\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0CEC;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_A;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A <<= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLe_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLe_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0CEC; /* data register */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word; /* magic value */\n");
  fprintf(stdout, "%s%s; /* back up bit0 */\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B; /* store old acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_B; /* add to acc */\n");
  fprintf(stdout, "%s%s; /* store carry flag */\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 1; /* add regA to itself */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0xFFF; /* toss excess bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLf_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLf_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLSLf 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLf_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLf_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLSLf 2\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRe_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRe_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* agh! I dislike these silly 12bit processors :P */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = 0x0DED;\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = flag_C = acc_a0 = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A <<= 4; /* get sign bit */\n");
  fprintf(stdout, "%sregister_A = (%s) & 0xFFF;\n", cur_tabs, SAR("register_A","5"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRe_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRe_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = 0x0DED;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 4;\n");
  fprintf(stdout, "%sregister_B = %s;\n", cur_tabs, SAR("register_B","5"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRf_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRf_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opASRf 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRf_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRf_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opASRf 2\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRDe_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRDe_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * Arithmetic shift right of D (A+B) .. B is high (sign bits).\n");
  fprintf(stdout, "%s%s", cur_tabs, " * divide by 2, but leave the sign bit the same. (ie: 1010 -> 1001)\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0EEE;\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word_2;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word; /* save new acc value */\n");
  fprintf(stdout, "%s%s; /* save old accA bit0 */\n", cur_tabs, SETA0 ("register_A & 0xFF"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A; /* save old acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_A;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A <<= 4;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 4;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word_2 = (register_B >> 4) << 15;\n");
  fprintf(stdout, "%sregister_B = %s;\n", cur_tabs, SAR("register_B","5"));
  fprintf(stdout, "%s%s", cur_tabs, "register_A = (register_A >> 1) | temp_word_2;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A >>= 4;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRDe_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRDe_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0EEE;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A & 0xFF"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_B;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 4;\n");
  fprintf(stdout, "%sregister_B = %s;\n", cur_tabs, SAR("register_B","5"));
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRDf_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRDf_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opASRDf 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opASRDf_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opASRDf_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opASRDf 2\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLDe_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLDe_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* LSLDe -- Left shift through both accumulators; lossy in middle. */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0FEF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_A;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "register_A <<= 1; /* logical shift left */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLDe_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLDe_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLSLD 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLDf_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLDf_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* LSLDf */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_A;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_A;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A <<= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLSLDf_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLSLDf_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* not 'the same' as the A->AA version above */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "CINEWORD temp_word = 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "cmp_new = temp_word;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETA0 ("register_A"));
  fprintf(stdout, "%s%s", cur_tabs, "cmp_old = register_B;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "temp_word += register_B;\n");
  fprintf(stdout, "%s%s;\n", cur_tabs, SETFC ("temp_word"));
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B <<= 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opJMP_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJMP_A_A (%02x) */\n", cur_tabs, opcode);

  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * simple jump; change PC and continue..\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s /* JMP() */;\n", cur_tabs, JMP());

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif

  fprintf(stdout, "%s%s", cur_tabs, "break; /* or continue? */\n");
}

CINESTATE opJMP_B_BB (int opcode)
{
  internal_test(opcode);
  /* Todo: steal code from opJMP_A_A */
  fprintf(stdout, "%s/* opJMP_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s; break /* JMP() */;\n", cur_tabs, JMP());
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJEI_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJEI_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (FromX & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	FromX |= 0xF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (!(CCPU_READPORT (CCPU_PORT_IOOUTPUTS) & 0x80))\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKY) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "else\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKX) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJEI_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJEI_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (FromX & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	FromX |= 0xF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (!(CCPU_READPORT (CCPU_PORT_IOOUTPUTS) & 0x80))\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKY) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "else\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKX) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJEI_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJEI_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (FromX & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	FromX |= 0xF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (!(CCPU_READPORT (CCPU_PORT_IOOUTPUTS) & 0x80))\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKY) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "else\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if ((CCPU_READPORT (CCPU_PORT_IN_JOYSTICKX) - (CINESWORD)FromX) < 0x800)\n");
  fprintf(stdout, "%s			{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

/* WARNING: THESE ARE THE FUNNY ONES SPECIFICALLY FOR TAILGUNNER */

  /* These instructions require the saved 'cmp_new' from a previous
     instruction.  Therefore on the first pass, we can tag that
     previous instruction so that it remembers the cmp_new value.
     Actually a better thing is to tag this instruction, and have the
     previous instruction do a lookahead test when it generates
     its code */


CINESTATE opJMI_A_A (int opcode)
{
  internal_test(opcode);
  
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJMI_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * previous instruction was not an ACC instruction, nor was the\n");
  fprintf(stdout, "%s%s", cur_tabs, " * instruction twice back a USB, therefore minus flag test the\n");
  fprintf(stdout, "%s%s", cur_tabs, " * current A-reg\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* negative acc? */\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (register_A & 0x800)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}	 /* yes -- do jump */\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJMI_AA_A (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJMI_AA_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* previous acc negative? Jump if so... */\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_old & 0x800)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJMI_BB_A (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJMI_BB_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (register_B & 0x800)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJMI_B_BB (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJMI_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (register_A & 0x800)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJLT_A_A (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJLT_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* jump if old acc equals new acc */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new < cmp_old)\n");
  fprintf(stdout, "%s	{ %s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJLT_B_BB (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJLT_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new < cmp_old)\n");
  fprintf(stdout, "%s	{ %s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJEQ_A_A (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJEQ_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* jump if equal */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new == cmp_old)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJEQ_B_BB (int opcode)
{
  internal_test(opcode);
  if (pass == PASS_1) {
    romFlags[register_PC] |= (TAG_REQUIRES_COMP_OLD | TAG_REQUIRES_CMP_NEW);
  }

  fprintf(stdout, "%s/* opJEQ_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new == cmp_old)\n");
  fprintf(stdout, "%s	{%s ; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJA0_A_A (int opcode)
{
  internal_test(opcode);

  /* I am not convinced that we need this extra acc_a0 variable
     *as well as* an extra carry-flag remembering variable  */

  fprintf(stdout, "%s/* opJA0_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (acc_a0 & 0x01)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJA0_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJA0_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (acc_a0 & 0x01)\n");
  fprintf(stdout, "%s	{%s; break /* JMP() */;}\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJNC_A_A (int opcode)
{
  internal_test(opcode);
  /* Use this opcode to test new carry and new jump code */
  fprintf(stdout, "%s/* opJNC_A_A (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%sif (!(%s /* GETFC() */ & 0xF0))\n", cur_tabs, GETFC());
  fprintf(stdout, "%s	{%s; break /* JMP() */;} /* no carry, so jump */\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#else
  fprintf(stdout, "%sif (!%s) {\n", cur_tabs, GETFC());
  if (register_J != 0xDEADBEEFUL) {
    fprintf(stdout, "%s	register_PC = 0x%04x /* JMP() */; /* no carry, so jump */\n", cur_tabs, register_J | (register_PC & 0xF000));
  } else {
    fprintf(stdout, "%s	register_PC = register_J | (register_PC & 0xF000)/* JMP() */; /* no carry, so jump */\n", cur_tabs, JMP());
  }
  fprintf(stdout, "%s%s", cur_tabs, "  break;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
#endif
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJNC_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJNC_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sif (!%s)\n", cur_tabs, GETFC());
  fprintf(stdout, "%s	{%s; break /* JMP() */;} /* no carry, so jump */\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJDR_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJDR_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * Calculate number of cycles executed since\n");
  fprintf(stdout, "%s%s", cur_tabs, " * last 'VDR' instruction, add two and use as\n");
  fprintf(stdout, "%s%s", cur_tabs, " * cycle count, never branch\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  register_A = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opJDR_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJDR_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * Calculate number of cycles executed since\n");
  fprintf(stdout, "%s%s", cur_tabs, " * last 'VDR' instruction, add two and use as\n");
  fprintf(stdout, "%s%s", cur_tabs, " * cycle count, never branch\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  register_B = 0xDEADBEEFUL;
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opNOP_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opNOP_A_A (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opNOP_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opNOP_B_BB (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJPP32_A_B (int opcode)
{
  internal_test(opcode);

  /* AHA!  Is this the *only* way we can jump between rom pages?
     If so, then can surely clean up the code of all the other jumps */

  fprintf(stdout, "%s/* opJPP32_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 00 = Offset 0000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 01 = Offset 1000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 02 = Offset 2000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 03 = Offset 3000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 04 = Offset 4000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 05 = Offset 5000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 06 = Offset 6000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 07 = Offset 7000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + ((register_P & 0x07) << 12);\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJPP32_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJPP32_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + ((register_P & 0x07) << 12);\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJPP16_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJPP16_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 00 = Offset 0000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 01 = Offset 1000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 02 = Offset 2000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " * 03 = Offset 3000h\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + ((register_P & 0x03) << 12);\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJPP16_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJPP16_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + ((register_P & 0x03) << 12);\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJMP_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJMP_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s /* JMP() */;\n", cur_tabs, JMP());
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJPP8_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJPP8_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * \"long jump\"; combine P and J to jump to a new far location (that can\n");
  fprintf(stdout, "%s%s", cur_tabs, " *	be more than 12 bits in address). After this jump, further jumps\n");
  fprintf(stdout, "%s%s", cur_tabs, " * are local to this new page.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  if (register_P != 0xDEADBEFUL) {
    if (register_J != 0xDEADBEEFUL) {
      fprintf(stdout, "%sregister_PC = 0x%04x; /* rom offset */\n", cur_tabs, register_PC = register_J + (((register_P & 0x03) - 1) << 12));
    } else {
      fprintf(stdout, "%sregister_PC = register_J + 0x%04x; /* rom offset */\n", cur_tabs, ((register_P & 0x03) - 1) << 12);
      register_PC = 0xDEADBEEFUL;                                                                             /* WHY -1 ??????????? */
      fprintf(stdout, "%s%s", cur_tabs, "/* WARNING: UNKNOWN JUMP DESTINATION - MAY FOUL UP CODE OPTIMISATIONS */\n");
    }
  } else {
    fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + (((register_P & 0x03) - 1) << 12);\n");
  }
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B; /* Does this hold true after a jump? */\n");
#else
  state = state_B;
#endif
  fprintf(stdout, "%s%s", cur_tabs, "break; /* WARNING: this code tags the next instruction as type B but in fact it's the jump dest that should be B */\n");
}

CINESTATE opJPP8_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJPP8_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "register_PC = register_J + (((register_P & 0x03) - 1) << 12);\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opJMI_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJMI_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (register_A & 0x800)\n");
  fprintf(stdout, "%s	%s /* JMP() */;\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJMI_AA_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJMI_AA_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opJMI 3\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJMI_BB_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJMI_BB_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opJMI 4\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJLT_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJLT_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new < cmp_old)\n");
  fprintf(stdout, "%s	%s /* JMP() */;\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJEQ_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJEQ_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "if (cmp_new == cmp_old)\n");
  fprintf(stdout, "%s	%s /* JMP() */;\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJA0_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJA0_A_B (%02x) */\n", cur_tabs, opcode);
/* Since this is the only occurance, it makes more sense surely to
   put the "&1" in the GETA0 macro... */
  fprintf(stdout, "%sif (%s & 0x01)\n", cur_tabs, GETA0());
  fprintf(stdout, "%s	%s /* JMP() */;\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJNC_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJNC_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%sif (!%s)\n", cur_tabs, GETFC());
  fprintf(stdout, "%s	%s /* JMP() */; /* if no carry, jump */\n", cur_tabs, JMP());
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opJDR_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opJDR_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* register_PC++; */\n");
  fprintf(stdout, "%s%s", cur_tabs, "fprintf (stderr, \"The hell? No PC incrementing?\n\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}


CINESTATE opNOP_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opNOP_A_B (%02x) */\n", cur_tabs, opcode);
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_B;\n");
#else
  state = state_B;
#endif
}

CINESTATE opLLT_A_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLLT_A_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "CINEBYTE temp_byte = 0;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "while (1)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		CINEWORD temp_word = register_A >> 8; /* register_A's high bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word &= 0x0A; /* only want PA11 and PA9 */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (temp_word)\n");
  fprintf(stdout, "%s%s", cur_tabs, "		{\n");
  fprintf(stdout, "%s%s", cur_tabs, "					temp_word ^= 0x0A; /* flip the bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "					if (temp_word)\n");
  fprintf(stdout, "%s%s", cur_tabs, "						break;			 /* if not zero, mismatch found */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word = register_B >> 8; /* regB's top bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word &= 0x0A; /* only want SA11 and SA9 */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (temp_word)\n");
  fprintf(stdout, "%s%s", cur_tabs, "		{\n");
  fprintf(stdout, "%s%s", cur_tabs, "					temp_word ^= 0x0A; /* flip bits */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "					if (temp_word)\n");
  fprintf(stdout, "%s%s", cur_tabs, "						break; /* if not zero, mismatch found */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_A <<= 1; /* shift regA */\n");
  fprintf(stdout, "%s%s", cur_tabs, "		register_B <<= 1; /* shift regB */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_byte ++;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		if (!temp_byte) /* WHAT GOES HERE? */;\n");

  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "			state = state_AA;\n");
#else
  state = state_AA;
#endif
  fprintf(stdout, "%s%s", cur_tabs, "/* try again */\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "vgShiftLength = temp_byte;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_A &= 0x0FFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "register_B &= 0x0FFF;\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opLLT_B_AA (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opLLT_B_AA (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opLLT 1\");\n");

  register_A = 0xDEADBEEFUL;
  register_B = 0xDEADBEEFUL;

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_AA;\n");
#else
  state = state_AA;
#endif
}

CINESTATE opVIN_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opVIN_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* set the starting address of a vector */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "FromX = register_A & 0xFFF; /* regA goes to x-coord */\n");
  fprintf(stdout, "%s%s", cur_tabs, "FromY = register_B & 0xFFF; /* regB goes to y-coord */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opVIN_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opVIN_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "FromX = register_A & 0xFFF; /* regA goes to x-coord */\n");
  fprintf(stdout, "%s%s", cur_tabs, "FromY = register_B & 0xFFF; /* regB goes to y-coord */\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}

CINESTATE opWAI_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opWAI_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* wait for a tick on the watchdog */\n");
  fprintf(stdout, "%s%s", cur_tabs, "bNewFrame = 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "bailOut = TRUE;\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state;\n");
#else
  state = state;
#endif
  fprintf(stdout, "%sregister_PC = 0x%04x;\n", cur_tabs, register_PC+1);
  fprintf(stdout, "%s%s", cur_tabs, "break;\n");
}

CINESTATE opWAI_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opWAI_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "bNewFrame = 1;\n");
  fprintf(stdout, "%s%s", cur_tabs, "bailOut = TRUE;\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state;\n");
#else
  state = state;
#endif
  fprintf(stdout, "%sregister_PC = 0x%04x;\n", cur_tabs, register_PC+1);
  fprintf(stdout, "%s%s", cur_tabs, "break;\n");
}

CINESTATE opVDR_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opVDR_A_A (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* set ending points and draw the vector, or buffer for a later draw. */\n");
  fprintf(stdout, "%s%s", cur_tabs, "int ToX = register_A & 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "int ToY = register_B & 0xFFF;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/*\n");
  fprintf(stdout, "%s%s", cur_tabs, " * shl 20, s.ar 20; this means that if the CCPU reg should be -ve,\n");
  fprintf(stdout, "%s%s", cur_tabs, " * we should be negative as well.. sign extended.\n");
  fprintf(stdout, "%s%s", cur_tabs, " */\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (FromX & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	FromX |= 0xFFFFF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (ToX & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	ToX |= 0xFFFFF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (FromY & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	FromY |= 0xFFFFF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (ToY & 0x800)\n");
  fprintf(stdout, "%s%s", cur_tabs, "	ToY |= 0xFFFFF000;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* figure out the vector */\n");
  fprintf(stdout, "%s%s", cur_tabs, "ToX -= FromX;\n");
  fprintf(stdout, "%sToX = %s;\n", cur_tabs, SAR("ToX","vgShiftLength"));
  fprintf(stdout, "%s%s", cur_tabs, "ToX += FromX;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "ToY -= FromY;\n");
  fprintf(stdout, "%sToY = %s;\n", cur_tabs, SAR("ToY","vgShiftLength"));
  fprintf(stdout, "%s%s", cur_tabs, "ToY += FromY;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* do orientation flipping, etc. */\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* NOTE: this has been removed on the assumption that the vector draw routine can do it all */\n");

  fprintf(stdout, "%s%s", cur_tabs, "#if !RAW_VECTORS\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (bFlipX)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		ToX = sdwGameXSize - ToX;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		FromX = sdwGameXSize - FromX;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (bFlipY)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		ToY = sdwGameYSize - ToY;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		FromY = sdwGameYSize - FromY;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "FromX += sdwXOffset;\n");
  fprintf(stdout, "%s%s", cur_tabs, "ToX += sdwXOffset;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "FromY += sdwYOffset;\n");
  fprintf(stdout, "%s%s", cur_tabs, "ToY += sdwYOffset;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* check real coords */\n");
  fprintf(stdout, "%s%s", cur_tabs, "if (bSwapXY)\n");
  fprintf(stdout, "%s%s", cur_tabs, "{\n");
  fprintf(stdout, "%s%s", cur_tabs, "		CINEWORD temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word = ToY;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		ToY = ToX;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		ToX = temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "		temp_word = FromY;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		FromY = FromX;\n");
  fprintf(stdout, "%s%s", cur_tabs, "		FromX = temp_word;\n");
  fprintf(stdout, "%s%s", cur_tabs, "}\n");
  fprintf(stdout, "%s%s", cur_tabs, "#endif\n");

  fprintf(stdout, "%s%s", cur_tabs, "\n");
  fprintf(stdout, "%s%s", cur_tabs, "/* render the line */\n");
  fprintf(stdout, "%s%s", cur_tabs, "CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);\n");
  fprintf(stdout, "%s%s", cur_tabs, "\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_A;\n");
#else
  state = state_A;
#endif
}

CINESTATE opVDR_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* opVDR_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "UNFINISHED (\"opVDR B 1\");\n");
#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "state = state_BB;\n");
#else
  state = state_BB;
#endif
}









CINESTATE tJPP_A_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJPP_A_B (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* MSIZE -- 0 = 4k, 1 = 8k, 2 = 16k, 3 = 32k */\n");

  switch (ccpu_msize) {

  case CCPU_MEMSIZE_4K:
  case CCPU_MEMSIZE_8K:
    return opJPP8_A_B (opcode);

  case CCPU_MEMSIZE_16K:
    return opJPP16_A_B (opcode);

  case CCPU_MEMSIZE_32K:
    return opJPP32_A_B (opcode);

  default:
    fprintf(stdout, "%s%s", cur_tabs, "fprintf (stderr, \"Out of range JPP!\n\");\n");
    return opJPP32_A_B (opcode);

  }

}

CINESTATE tJPP_B_BB (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJPP_B_BB (%02x) */\n", cur_tabs, opcode);
  fprintf(stdout, "%s%s", cur_tabs, "/* MSIZE -- 0 = 4k, 1 = 8k, 2 = 16k, 3 = 32k */\n");

  switch (ccpu_msize)
  {
    case CCPU_MEMSIZE_4K:
    case CCPU_MEMSIZE_8K:
      return opJPP8_B_BB (opcode);
    case CCPU_MEMSIZE_16K:
      return opJPP16_B_BB (opcode);
    case CCPU_MEMSIZE_32K:
      return opJPP32_B_BB (opcode);
    default:
      fprintf(stderr, "Out of range JPP!\n");
  }

#ifdef SAFECODE
  fprintf(stdout, "%s%s", cur_tabs, "/* state = state; */\n");
#else
  state = state;
#endif
}



CINESTATE tJMI_A_B (int opcode)
{
  internal_test(opcode);
  /* again, all compile-time tests */
  fprintf(stdout, "%s/* tJMI_A_B (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_A_B (opcode) : opJEI_A_B (opcode);
}

CINESTATE tJMI_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_A_A (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_A_A (opcode) : opJEI_A_A (opcode);
}

CINESTATE tJMI_AA_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_AA_B (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_AA_B (opcode) : opJEI_AA_B (opcode);
}

CINESTATE tJMI_AA_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_AA_A (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_AA_A (opcode) : opJEI_A_A (opcode);
}

CINESTATE tJMI_B_BB1 (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_B_BB1 (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_B_BB (opcode) : opJEI_B_BB (opcode);
}

CINESTATE tJMI_BB_B (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_BB_B (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_BB_B (opcode) : opJEI_A_B (opcode);
}

CINESTATE tJMI_BB_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tJMI_BB_A (%02x) */\n", cur_tabs, opcode);
  return (ccpu_jmi_dip) ? opJMI_BB_A (opcode) : opJEI_A_A (opcode);
}


CINESTATE tOUT_A_A (int opcode)
{
  internal_test(opcode);
  fprintf(stdout, "%s/* tOUT_A_A (%02x) */\n", cur_tabs, opcode);

  switch (ccpu_monitor) { /* Known at translate time */

  case CCPU_MONITOR_16LEV:
    return opOUT16_A_A (opcode);

  case CCPU_MONITOR_64LEV:
    return opOUT64_A_A (opcode);

  case CCPU_MONITOR_WOWCOL:
    return opOUTWW_A_A (opcode);

  default: /* This for tailgunner */
    return opOUTbi_A_A (opcode);
  }
}

CINESTATE tOUT_B_BB (int opcode)
{
  internal_test(opcode);
  /* see above */
  fprintf(stdout, "%s/* tOUT_B_BB (%02x) */\n", cur_tabs, opcode);

  switch (ccpu_monitor)
  {

    /* These three are in error if tailgunner */
    case CCPU_MONITOR_16LEV:
      return opOUT16_B_BB (opcode);
    case CCPU_MONITOR_64LEV:
      return opOUT64_B_BB (opcode);
    case CCPU_MONITOR_WOWCOL:
      return opOUTWW_B_BB (opcode);

    default: /* Tailgunner */
      return opOUTbi_B_BB (opcode);
  }
}