/* 
   Pcm: a PC eMulator
   Copyright (C) 1992 Electronetics, Inc.  All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * operand/effective address/register determination
 */
#include "sim.h"

unsigned char *word_operand(pc)
unsigned char *pc; {
  unsigned short offset;

  switch (*pc++) {
/*
 * Register indirect
 */
  case 0000: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0010: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0020: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0030: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0040: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0050: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0060: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0070: EADDR1(DATA, (BX+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0001: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0011: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0021: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0031: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0041: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0051: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0061: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0071: EADDR1(DATA, (BX+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0002: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0012: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0022: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0032: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0042: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0052: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0062: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0072: EADDR1(STACK, (BP+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0003: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0013: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0023: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0033: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0043: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0053: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0063: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0073: EADDR1(STACK, (BP+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0004: EADDR1(DATA, SI); REGPTR = (unsigned char *)&AX; return pc;
  case 0014: EADDR1(DATA, SI); REGPTR = (unsigned char *)&CX; return pc;
  case 0024: EADDR1(DATA, SI); REGPTR = (unsigned char *)&DX; return pc;
  case 0034: EADDR1(DATA, SI); REGPTR = (unsigned char *)&BX; return pc;
  case 0044: EADDR1(DATA, SI); REGPTR = (unsigned char *)&SP; return pc;
  case 0054: EADDR1(DATA, SI); REGPTR = (unsigned char *)&BP; return pc;
  case 0064: EADDR1(DATA, SI); REGPTR = (unsigned char *)&SI; return pc;
  case 0074: EADDR1(DATA, SI); REGPTR = (unsigned char *)&DI; return pc;

  case 0005: EADDR1(DATA, DI); REGPTR = (unsigned char *)&AX; return pc;
  case 0015: EADDR1(DATA, DI); REGPTR = (unsigned char *)&CX; return pc;
  case 0025: EADDR1(DATA, DI); REGPTR = (unsigned char *)&DX; return pc;
  case 0035: EADDR1(DATA, DI); REGPTR = (unsigned char *)&BX; return pc;
  case 0045: EADDR1(DATA, DI); REGPTR = (unsigned char *)&SP; return pc;
  case 0055: EADDR1(DATA, DI); REGPTR = (unsigned char *)&BP; return pc;
  case 0065: EADDR1(DATA, DI); REGPTR = (unsigned char *)&SI; return pc;
  case 0075: EADDR1(DATA, DI); REGPTR = (unsigned char *)&DI; return pc;

  case 0006: EADDR2(DATA, 0); REGPTR = (unsigned char *)&AX; return pc;
  case 0016: EADDR2(DATA, 0); REGPTR = (unsigned char *)&CX; return pc;
  case 0026: EADDR2(DATA, 0); REGPTR = (unsigned char *)&DX; return pc;
  case 0036: EADDR2(DATA, 0); REGPTR = (unsigned char *)&BX; return pc;
  case 0046: EADDR2(DATA, 0); REGPTR = (unsigned char *)&SP; return pc;
  case 0056: EADDR2(DATA, 0); REGPTR = (unsigned char *)&BP; return pc;
  case 0066: EADDR2(DATA, 0); REGPTR = (unsigned char *)&SI; return pc;
  case 0076: EADDR2(DATA, 0); REGPTR = (unsigned char *)&DI; return pc;

  case 0007: EADDR1(DATA, BX); REGPTR = (unsigned char *)&AX; return pc;
  case 0017: EADDR1(DATA, BX); REGPTR = (unsigned char *)&CX; return pc;
  case 0027: EADDR1(DATA, BX); REGPTR = (unsigned char *)&DX; return pc;
  case 0037: EADDR1(DATA, BX); REGPTR = (unsigned char *)&BX; return pc;
  case 0047: EADDR1(DATA, BX); REGPTR = (unsigned char *)&SP; return pc;
  case 0057: EADDR1(DATA, BX); REGPTR = (unsigned char *)&BP; return pc;
  case 0067: EADDR1(DATA, BX); REGPTR = (unsigned char *)&SI; return pc;
  case 0077: EADDR1(DATA, BX); REGPTR = (unsigned char *)&DI; return pc;
/*
 * 8-bit displacements
 */
  case 0100: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0110: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0120: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0130: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0140: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0150: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0160: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0170: EADDR3(DATA, (BX+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0101: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0111: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0121: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0131: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0141: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0151: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0161: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0171: EADDR3(DATA, (BX+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0102: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0112: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0122: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0132: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0142: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0152: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0162: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0172: EADDR3(STACK, (BP+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0103: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0113: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0123: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0133: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0143: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0153: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0163: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0173: EADDR3(STACK, (BP+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0104: EADDR3(DATA, SI); REGPTR = (unsigned char *)&AX; return pc;
  case 0114: EADDR3(DATA, SI); REGPTR = (unsigned char *)&CX; return pc;
  case 0124: EADDR3(DATA, SI); REGPTR = (unsigned char *)&DX; return pc;
  case 0134: EADDR3(DATA, SI); REGPTR = (unsigned char *)&BX; return pc;
  case 0144: EADDR3(DATA, SI); REGPTR = (unsigned char *)&SP; return pc;
  case 0154: EADDR3(DATA, SI); REGPTR = (unsigned char *)&BP; return pc;
  case 0164: EADDR3(DATA, SI); REGPTR = (unsigned char *)&SI; return pc;
  case 0174: EADDR3(DATA, SI); REGPTR = (unsigned char *)&DI; return pc;

  case 0105: EADDR3(DATA, DI); REGPTR = (unsigned char *)&AX; return pc;
  case 0115: EADDR3(DATA, DI); REGPTR = (unsigned char *)&CX; return pc;
  case 0125: EADDR3(DATA, DI); REGPTR = (unsigned char *)&DX; return pc;
  case 0135: EADDR3(DATA, DI); REGPTR = (unsigned char *)&BX; return pc;
  case 0145: EADDR3(DATA, DI); REGPTR = (unsigned char *)&SP; return pc;
  case 0155: EADDR3(DATA, DI); REGPTR = (unsigned char *)&BP; return pc;
  case 0165: EADDR3(DATA, DI); REGPTR = (unsigned char *)&SI; return pc;
  case 0175: EADDR3(DATA, DI); REGPTR = (unsigned char *)&DI; return pc;

  case 0106: EADDR3(STACK, BP); REGPTR = (unsigned char *)&AX; return pc;
  case 0116: EADDR3(STACK, BP); REGPTR = (unsigned char *)&CX; return pc;
  case 0126: EADDR3(STACK, BP); REGPTR = (unsigned char *)&DX; return pc;
  case 0136: EADDR3(STACK, BP); REGPTR = (unsigned char *)&BX; return pc;
  case 0146: EADDR3(STACK, BP); REGPTR = (unsigned char *)&SP; return pc;
  case 0156: EADDR3(STACK, BP); REGPTR = (unsigned char *)&BP; return pc;
  case 0166: EADDR3(STACK, BP); REGPTR = (unsigned char *)&SI; return pc;
  case 0176: EADDR3(STACK, BP); REGPTR = (unsigned char *)&DI; return pc;

  case 0107: EADDR3(DATA, BX); REGPTR = (unsigned char *)&AX; return pc;
  case 0117: EADDR3(DATA, BX); REGPTR = (unsigned char *)&CX; return pc;
  case 0127: EADDR3(DATA, BX); REGPTR = (unsigned char *)&DX; return pc;
  case 0137: EADDR3(DATA, BX); REGPTR = (unsigned char *)&BX; return pc;
  case 0147: EADDR3(DATA, BX); REGPTR = (unsigned char *)&SP; return pc;
  case 0157: EADDR3(DATA, BX); REGPTR = (unsigned char *)&BP; return pc;
  case 0167: EADDR3(DATA, BX); REGPTR = (unsigned char *)&SI; return pc;
  case 0177: EADDR3(DATA, BX); REGPTR = (unsigned char *)&DI; return pc;
/*
 * 16-bit displacements
 */
  case 0200: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0210: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0220: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0230: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0240: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0250: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0260: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0270: EADDR2(DATA, (BX+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0201: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0211: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0221: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0231: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0241: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0251: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0261: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0271: EADDR2(DATA, (BX+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0202: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0212: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0222: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0232: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0242: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0252: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0262: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0272: EADDR2(STACK, (BP+SI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0203: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&AX; return pc;
  case 0213: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&CX; return pc;
  case 0223: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&DX; return pc;
  case 0233: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&BX; return pc;
  case 0243: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&SP; return pc;
  case 0253: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&BP; return pc;
  case 0263: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&SI; return pc;
  case 0273: EADDR2(STACK, (BP+DI)); REGPTR = (unsigned char *)&DI; return pc;

  case 0204: EADDR2(DATA, SI); REGPTR = (unsigned char *)&AX; return pc;
  case 0214: EADDR2(DATA, SI); REGPTR = (unsigned char *)&CX; return pc;
  case 0224: EADDR2(DATA, SI); REGPTR = (unsigned char *)&DX; return pc;
  case 0234: EADDR2(DATA, SI); REGPTR = (unsigned char *)&BX; return pc;
  case 0244: EADDR2(DATA, SI); REGPTR = (unsigned char *)&SP; return pc;
  case 0254: EADDR2(DATA, SI); REGPTR = (unsigned char *)&BP; return pc;
  case 0264: EADDR2(DATA, SI); REGPTR = (unsigned char *)&SI; return pc;
  case 0274: EADDR2(DATA, SI); REGPTR = (unsigned char *)&DI; return pc;

  case 0205: EADDR2(DATA, DI); REGPTR = (unsigned char *)&AX; return pc;
  case 0215: EADDR2(DATA, DI); REGPTR = (unsigned char *)&CX; return pc;
  case 0225: EADDR2(DATA, DI); REGPTR = (unsigned char *)&DX; return pc;
  case 0235: EADDR2(DATA, DI); REGPTR = (unsigned char *)&BX; return pc;
  case 0245: EADDR2(DATA, DI); REGPTR = (unsigned char *)&SP; return pc;
  case 0255: EADDR2(DATA, DI); REGPTR = (unsigned char *)&BP; return pc;
  case 0265: EADDR2(DATA, DI); REGPTR = (unsigned char *)&SI; return pc;
  case 0275: EADDR2(DATA, DI); REGPTR = (unsigned char *)&DI; return pc;

  case 0206: EADDR2(STACK, BP); REGPTR = (unsigned char *)&AX; return pc;
  case 0216: EADDR2(STACK, BP); REGPTR = (unsigned char *)&CX; return pc;
  case 0226: EADDR2(STACK, BP); REGPTR = (unsigned char *)&DX; return pc;
  case 0236: EADDR2(STACK, BP); REGPTR = (unsigned char *)&BX; return pc;
  case 0246: EADDR2(STACK, BP); REGPTR = (unsigned char *)&SP; return pc;
  case 0256: EADDR2(STACK, BP); REGPTR = (unsigned char *)&BP; return pc;
  case 0266: EADDR2(STACK, BP); REGPTR = (unsigned char *)&SI; return pc;
  case 0276: EADDR2(STACK, BP); REGPTR = (unsigned char *)&DI; return pc;

  case 0207: EADDR2(DATA, BX); REGPTR = (unsigned char *)&AX; return pc;
  case 0217: EADDR2(DATA, BX); REGPTR = (unsigned char *)&CX; return pc;
  case 0227: EADDR2(DATA, BX); REGPTR = (unsigned char *)&DX; return pc;
  case 0237: EADDR2(DATA, BX); REGPTR = (unsigned char *)&BX; return pc;
  case 0247: EADDR2(DATA, BX); REGPTR = (unsigned char *)&SP; return pc;
  case 0257: EADDR2(DATA, BX); REGPTR = (unsigned char *)&BP; return pc;
  case 0267: EADDR2(DATA, BX); REGPTR = (unsigned char *)&SI; return pc;
  case 0277: EADDR2(DATA, BX); REGPTR = (unsigned char *)&DI; return pc;
/*
 * Register direct
 */
  case 0300: EADDR4(AX); REGPTR = (unsigned char *)&AX; return pc;
  case 0310: EADDR4(AX); REGPTR = (unsigned char *)&CX; return pc;
  case 0320: EADDR4(AX); REGPTR = (unsigned char *)&DX; return pc;
  case 0330: EADDR4(AX); REGPTR = (unsigned char *)&BX; return pc;
  case 0340: EADDR4(AX); REGPTR = (unsigned char *)&SP; return pc;
  case 0350: EADDR4(AX); REGPTR = (unsigned char *)&BP; return pc;
  case 0360: EADDR4(AX); REGPTR = (unsigned char *)&SI; return pc;
  case 0370: EADDR4(AX); REGPTR = (unsigned char *)&DI; return pc;

  case 0301: EADDR4(CX); REGPTR = (unsigned char *)&AX; return pc;
  case 0311: EADDR4(CX); REGPTR = (unsigned char *)&CX; return pc;
  case 0321: EADDR4(CX); REGPTR = (unsigned char *)&DX; return pc;
  case 0331: EADDR4(CX); REGPTR = (unsigned char *)&BX; return pc;
  case 0341: EADDR4(CX); REGPTR = (unsigned char *)&SP; return pc;
  case 0351: EADDR4(CX); REGPTR = (unsigned char *)&BP; return pc;
  case 0361: EADDR4(CX); REGPTR = (unsigned char *)&SI; return pc;
  case 0371: EADDR4(CX); REGPTR = (unsigned char *)&DI; return pc;

  case 0302: EADDR4(DX); REGPTR = (unsigned char *)&AX; return pc;
  case 0312: EADDR4(DX); REGPTR = (unsigned char *)&CX; return pc;
  case 0322: EADDR4(DX); REGPTR = (unsigned char *)&DX; return pc;
  case 0332: EADDR4(DX); REGPTR = (unsigned char *)&BX; return pc;
  case 0342: EADDR4(DX); REGPTR = (unsigned char *)&SP; return pc;
  case 0352: EADDR4(DX); REGPTR = (unsigned char *)&BP; return pc;
  case 0362: EADDR4(DX); REGPTR = (unsigned char *)&SI; return pc;
  case 0372: EADDR4(DX); REGPTR = (unsigned char *)&DI; return pc;

  case 0303: EADDR4(BX); REGPTR = (unsigned char *)&AX; return pc;
  case 0313: EADDR4(BX); REGPTR = (unsigned char *)&CX; return pc;
  case 0323: EADDR4(BX); REGPTR = (unsigned char *)&DX; return pc;
  case 0333: EADDR4(BX); REGPTR = (unsigned char *)&BX; return pc;
  case 0343: EADDR4(BX); REGPTR = (unsigned char *)&SP; return pc;
  case 0353: EADDR4(BX); REGPTR = (unsigned char *)&BP; return pc;
  case 0363: EADDR4(BX); REGPTR = (unsigned char *)&SI; return pc;
  case 0373: EADDR4(BX); REGPTR = (unsigned char *)&DI; return pc;

  case 0304: EADDR4(SP); REGPTR = (unsigned char *)&AX; return pc;
  case 0314: EADDR4(SP); REGPTR = (unsigned char *)&CX; return pc;
  case 0324: EADDR4(SP); REGPTR = (unsigned char *)&DX; return pc;
  case 0334: EADDR4(SP); REGPTR = (unsigned char *)&BX; return pc;
  case 0344: EADDR4(SP); REGPTR = (unsigned char *)&SP; return pc;
  case 0354: EADDR4(SP); REGPTR = (unsigned char *)&BP; return pc;
  case 0364: EADDR4(SP); REGPTR = (unsigned char *)&SI; return pc;
  case 0374: EADDR4(SP); REGPTR = (unsigned char *)&DI; return pc;

  case 0305: EADDR4(BP); REGPTR = (unsigned char *)&AX; return pc;
  case 0315: EADDR4(BP); REGPTR = (unsigned char *)&CX; return pc;
  case 0325: EADDR4(BP); REGPTR = (unsigned char *)&DX; return pc;
  case 0335: EADDR4(BP); REGPTR = (unsigned char *)&BX; return pc;
  case 0345: EADDR4(BP); REGPTR = (unsigned char *)&SP; return pc;
  case 0355: EADDR4(BP); REGPTR = (unsigned char *)&BP; return pc;
  case 0365: EADDR4(BP); REGPTR = (unsigned char *)&SI; return pc;
  case 0375: EADDR4(BP); REGPTR = (unsigned char *)&DI; return pc;

  case 0306: EADDR4(SI); REGPTR = (unsigned char *)&AX; return pc;
  case 0316: EADDR4(SI); REGPTR = (unsigned char *)&CX; return pc;
  case 0326: EADDR4(SI); REGPTR = (unsigned char *)&DX; return pc;
  case 0336: EADDR4(SI); REGPTR = (unsigned char *)&BX; return pc;
  case 0346: EADDR4(SI); REGPTR = (unsigned char *)&SP; return pc;
  case 0356: EADDR4(SI); REGPTR = (unsigned char *)&BP; return pc;
  case 0366: EADDR4(SI); REGPTR = (unsigned char *)&SI; return pc;
  case 0376: EADDR4(SI); REGPTR = (unsigned char *)&DI; return pc;

  case 0307: EADDR4(DI); REGPTR = (unsigned char *)&AX; return pc;
  case 0317: EADDR4(DI); REGPTR = (unsigned char *)&CX; return pc;
  case 0327: EADDR4(DI); REGPTR = (unsigned char *)&DX; return pc;
  case 0337: EADDR4(DI); REGPTR = (unsigned char *)&BX; return pc;
  case 0347: EADDR4(DI); REGPTR = (unsigned char *)&SP; return pc;
  case 0357: EADDR4(DI); REGPTR = (unsigned char *)&BP; return pc;
  case 0367: EADDR4(DI); REGPTR = (unsigned char *)&SI; return pc;
  case 0377: EADDR4(DI); REGPTR = (unsigned char *)&DI; return pc;
  }
  return pc;
}

unsigned char *word_operand2(pc)
unsigned char *pc; {
  unsigned short offset;

  switch (*pc++) {
/*
 * Register indirect
 */
  case 0000: AX = BX+SI; return pc;
  case 0010: CX = BX+SI; return pc;
  case 0020: DX = BX+SI; return pc;
  case 0030: BX = BX+SI; return pc;
  case 0040: SP = BX+SI; return pc;
  case 0050: BP = BX+SI; return pc;
  case 0060: SI = BX+SI; return pc;
  case 0070: DI = BX+SI; return pc;

  case 0001: AX = BX+DI; return pc;
  case 0011: CX = BX+DI; return pc;
  case 0021: DX = BX+DI; return pc;
  case 0031: BX = BX+DI; return pc;
  case 0041: SP = BX+DI; return pc;
  case 0051: BP = BX+DI; return pc;
  case 0061: SI = BX+DI; return pc;
  case 0071: DI = BX+DI; return pc;

  case 0002: AX = BP+SI; return pc;
  case 0012: CX = BP+SI; return pc;
  case 0022: DX = BP+SI; return pc;
  case 0032: BX = BP+SI; return pc;
  case 0042: SP = BP+SI; return pc;
  case 0052: BP = BP+SI; return pc;
  case 0062: SI = BP+SI; return pc;
  case 0072: DI = BP+SI; return pc;

  case 0003: AX = BP+DI; return pc;
  case 0013: CX = BP+DI; return pc;
  case 0023: DX = BP+DI; return pc;
  case 0033: BX = BP+DI; return pc;
  case 0043: SP = BP+DI; return pc;
  case 0053: BP = BP+DI; return pc;
  case 0063: SI = BP+DI; return pc;
  case 0073: DI = BP+DI; return pc;

  case 0004: AX = SI; return pc;
  case 0014: CX = SI; return pc;
  case 0024: DX = SI; return pc;
  case 0034: BX = SI; return pc;
  case 0044: SP = SI; return pc;
  case 0054: BP = SI; return pc;
  case 0064: SI = SI; return pc;
  case 0074: DI = SI; return pc;

  case 0005: AX = DI; return pc;
  case 0015: CX = DI; return pc;
  case 0025: DX = DI; return pc;
  case 0035: BX = DI; return pc;
  case 0045: SP = DI; return pc;
  case 0055: BP = DI; return pc;
  case 0065: SI = DI; return pc;
  case 0075: DI = DI; return pc;

  case 0006: AL = *pc++; AH = *pc++; return pc;
  case 0016: CL = *pc++; CH = *pc++; return pc;
  case 0026: DL = *pc++; DH = *pc++; return pc;
  case 0036: BL = *pc++; BH = *pc++; return pc;
  case 0046: SPL = *pc++; SPH = *pc++; return pc;
  case 0056: BPL = *pc++; BPH = *pc++; return pc;
  case 0066: SIL = *pc++; SIH = *pc++; return pc;
  case 0076: DIL = *pc++; DIH = *pc++; return pc;

  case 0007: AX = BX; return pc;
  case 0017: CX = BX; return pc;
  case 0027: DX = BX; return pc;
  case 0037: BX = BX; return pc;
  case 0047: SP = BX; return pc;
  case 0057: BP = BX; return pc;
  case 0067: SI = BX; return pc;
  case 0077: DI = BX; return pc;

/*
 * 8-bit displacements
 */
  case 0100: AX = BX+SI+(char)*pc++; return pc;
  case 0110: CX = BX+SI+(char)*pc++; return pc;
  case 0120: DX = BX+SI+(char)*pc++; return pc;
  case 0130: BX = BX+SI+(char)*pc++; return pc;
  case 0140: SP = BX+SI+(char)*pc++; return pc;
  case 0150: BP = BX+SI+(char)*pc++; return pc;
  case 0160: SI = BX+SI+(char)*pc++; return pc;
  case 0170: DI = BX+SI+(char)*pc++; return pc;

  case 0101: AX = BX+DI+(char)*pc++; return pc;
  case 0111: CX = BX+DI+(char)*pc++; return pc;
  case 0121: DX = BX+DI+(char)*pc++; return pc;
  case 0131: BX = BX+DI+(char)*pc++; return pc;
  case 0141: SP = BX+DI+(char)*pc++; return pc;
  case 0151: BP = BX+DI+(char)*pc++; return pc;
  case 0161: SI = BX+DI+(char)*pc++; return pc;
  case 0171: DI = BX+DI+(char)*pc++; return pc;

  case 0102: AX = BP+SI+(char)*pc++; return pc;
  case 0112: CX = BP+SI+(char)*pc++; return pc;
  case 0122: DX = BP+SI+(char)*pc++; return pc;
  case 0132: BX = BP+SI+(char)*pc++; return pc;
  case 0142: SP = BP+SI+(char)*pc++; return pc;
  case 0152: BP = BP+SI+(char)*pc++; return pc;
  case 0162: SI = BP+SI+(char)*pc++; return pc;
  case 0172: DI = BP+SI+(char)*pc++; return pc;

  case 0103: AX = BP+DI+(char)*pc++; return pc;
  case 0113: CX = BP+DI+(char)*pc++; return pc;
  case 0123: DX = BP+DI+(char)*pc++; return pc;
  case 0133: BX = BP+DI+(char)*pc++; return pc;
  case 0143: SP = BP+DI+(char)*pc++; return pc;
  case 0153: BP = BP+DI+(char)*pc++; return pc;
  case 0163: SI = BP+DI+(char)*pc++; return pc;
  case 0173: DI = BP+DI+(char)*pc++; return pc;

  case 0104: AX = SI+(char)*pc++; return pc;
  case 0114: CX = SI+(char)*pc++; return pc;
  case 0124: DX = SI+(char)*pc++; return pc;
  case 0134: BX = SI+(char)*pc++; return pc;
  case 0144: SP = SI+(char)*pc++; return pc;
  case 0154: BP = SI+(char)*pc++; return pc;
  case 0164: SI = SI+(char)*pc++; return pc;
  case 0174: DI = SI+(char)*pc++; return pc;

  case 0105: AX = DI+(char)*pc++; return pc;
  case 0115: CX = DI+(char)*pc++; return pc;
  case 0125: DX = DI+(char)*pc++; return pc;
  case 0135: BX = DI+(char)*pc++; return pc;
  case 0145: SP = DI+(char)*pc++; return pc;
  case 0155: BP = DI+(char)*pc++; return pc;
  case 0165: SI = DI+(char)*pc++; return pc;
  case 0175: DI = DI+(char)*pc++; return pc;

  case 0106: AX = BP+(char)*pc++; return pc;
  case 0116: CX = BP+(char)*pc++; return pc;
  case 0126: DX = BP+(char)*pc++; return pc;
  case 0136: BX = BP+(char)*pc++; return pc;
  case 0146: SP = BP+(char)*pc++; return pc;
  case 0156: BP = BP+(char)*pc++; return pc;
  case 0166: SI = BP+(char)*pc++; return pc;
  case 0176: DI = BP+(char)*pc++; return pc;

  case 0107: AX = BX+(char)*pc++; return pc;
  case 0117: CX = BX+(char)*pc++; return pc;
  case 0127: DX = BX+(char)*pc++; return pc;
  case 0137: BX = BX+(char)*pc++; return pc;
  case 0147: SP = BX+(char)*pc++; return pc;
  case 0157: BP = BX+(char)*pc++; return pc;
  case 0167: SI = BX+(char)*pc++; return pc;
  case 0177: DI = BX+(char)*pc++; return pc;

/*
 * 16-bit displacements
 */

  case 0200: AX = BX+SI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0210: CX = BX+SI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0220: DX = BX+SI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0230: BX = BX+SI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0240: SP = BX+SI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0250: BP = BX+SI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0260: SI = BX+SI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0270: DI = BX+SI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0201: AX = BX+DI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0211: CX = BX+DI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0221: DX = BX+DI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0231: BX = BX+DI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0241: SP = BX+DI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0251: BP = BX+DI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0261: SI = BX+DI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0271: DI = BX+DI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0202: AX = BP+SI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0212: CX = BP+SI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0222: DX = BP+SI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0232: BX = BP+SI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0242: SP = BP+SI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0252: BP = BP+SI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0262: SI = BP+SI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0272: DI = BP+SI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0203: AX = BP+DI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0213: CX = BP+DI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0223: DX = BP+DI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0233: BX = BP+DI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0243: SP = BP+DI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0253: BP = BP+DI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0263: SI = BP+DI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0273: DI = BP+DI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0204: AX = SI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0214: CX = SI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0224: DX = SI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0234: BX = SI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0244: SP = SI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0254: BP = SI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0264: SI = SI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0274: DI = SI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0205: AX = DI+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0215: CX = DI+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0225: DX = DI+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0235: BX = DI+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0245: SP = DI+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0255: BP = DI+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0265: SI = DI+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0275: DI = DI+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0206: AX = BP+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0216: CX = BP+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0226: DX = BP+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0236: BX = BP+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0246: SP = BP+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0256: BP = BP+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0266: SI = BP+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0276: DI = BP+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

  case 0207: AX = BX+*pc++; AX += (unsigned int)*pc++ << 8; return pc;
  case 0217: CX = BX+*pc++; CX += (unsigned int)*pc++ << 8; return pc;
  case 0227: DX = BX+*pc++; DX += (unsigned int)*pc++ << 8; return pc;
  case 0237: BX = BX+*pc++; BX += (unsigned int)*pc++ << 8; return pc;
  case 0247: SP = BX+*pc++; SP += (unsigned int)*pc++ << 8; return pc;
  case 0257: BP = BX+*pc++; BP += (unsigned int)*pc++ << 8; return pc;
  case 0267: SI = BX+*pc++; SI += (unsigned int)*pc++ << 8; return pc;
  case 0277: DI = BX+*pc++; DI += (unsigned int)*pc++ << 8; return pc;

/*
 * Register direct (not allowed)
 */
  default: return unk_op(pc); 
  }
  /* NOTREACHED */
}

unsigned char *byte_operand(pc)
unsigned char *pc; {
  unsigned short offset;

  switch (*pc++) {
/*
 * Register indirect
 */
  case 0000: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0010: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0020: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0030: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0040: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0050: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0060: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0070: EADDR5(DATA, (BX+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0001: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0011: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0021: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0031: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0041: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0051: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0061: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0071: EADDR5(DATA, (BX+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0002: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0012: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0022: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0032: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0042: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0052: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0062: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0072: EADDR5(STACK, (BP+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0003: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0013: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0023: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0033: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0043: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0053: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0063: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0073: EADDR5(STACK, (BP+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0004: EADDR5(DATA, SI); REGPTR = (unsigned char *)&AL; return pc;
  case 0014: EADDR5(DATA, SI); REGPTR = (unsigned char *)&CL; return pc;
  case 0024: EADDR5(DATA, SI); REGPTR = (unsigned char *)&DL; return pc;
  case 0034: EADDR5(DATA, SI); REGPTR = (unsigned char *)&BL; return pc;
  case 0044: EADDR5(DATA, SI); REGPTR = (unsigned char *)&AH; return pc;
  case 0054: EADDR5(DATA, SI); REGPTR = (unsigned char *)&CH; return pc;
  case 0064: EADDR5(DATA, SI); REGPTR = (unsigned char *)&DH; return pc;
  case 0074: EADDR5(DATA, SI); REGPTR = (unsigned char *)&BH; return pc;

  case 0005: EADDR5(DATA, DI); REGPTR = (unsigned char *)&AL; return pc;
  case 0015: EADDR5(DATA, DI); REGPTR = (unsigned char *)&CL; return pc;
  case 0025: EADDR5(DATA, DI); REGPTR = (unsigned char *)&DL; return pc;
  case 0035: EADDR5(DATA, DI); REGPTR = (unsigned char *)&BL; return pc;
  case 0045: EADDR5(DATA, DI); REGPTR = (unsigned char *)&AH; return pc;
  case 0055: EADDR5(DATA, DI); REGPTR = (unsigned char *)&CH; return pc;
  case 0065: EADDR5(DATA, DI); REGPTR = (unsigned char *)&DH; return pc;
  case 0075: EADDR5(DATA, DI); REGPTR = (unsigned char *)&BH; return pc;

  case 0006: EADDR6(DATA, 0); REGPTR = (unsigned char *)&AL; return pc;
  case 0016: EADDR6(DATA, 0); REGPTR = (unsigned char *)&CL; return pc;
  case 0026: EADDR6(DATA, 0); REGPTR = (unsigned char *)&DL; return pc;
  case 0036: EADDR6(DATA, 0); REGPTR = (unsigned char *)&BL; return pc;
  case 0046: EADDR6(DATA, 0); REGPTR = (unsigned char *)&AH; return pc;
  case 0056: EADDR6(DATA, 0); REGPTR = (unsigned char *)&CH; return pc;
  case 0066: EADDR6(DATA, 0); REGPTR = (unsigned char *)&DH; return pc;
  case 0076: EADDR6(DATA, 0); REGPTR = (unsigned char *)&BH; return pc;

  case 0007: EADDR5(DATA, BX); REGPTR = (unsigned char *)&AL; return pc;
  case 0017: EADDR5(DATA, BX); REGPTR = (unsigned char *)&CL; return pc;
  case 0027: EADDR5(DATA, BX); REGPTR = (unsigned char *)&DL; return pc;
  case 0037: EADDR5(DATA, BX); REGPTR = (unsigned char *)&BL; return pc;
  case 0047: EADDR5(DATA, BX); REGPTR = (unsigned char *)&AH; return pc;
  case 0057: EADDR5(DATA, BX); REGPTR = (unsigned char *)&CH; return pc;
  case 0067: EADDR5(DATA, BX); REGPTR = (unsigned char *)&DH; return pc;
  case 0077: EADDR5(DATA, BX); REGPTR = (unsigned char *)&BH; return pc;
/*
 * 8-bit displacements
 */
  case 0100: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0110: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0120: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0130: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0140: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0150: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0160: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0170: EADDR7(DATA, (BX+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0101: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0111: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0121: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0131: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0141: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0151: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0161: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0171: EADDR7(DATA, (BX+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0102: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0112: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0122: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0132: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0142: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0152: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0162: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0172: EADDR7(STACK, (BP+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0103: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0113: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0123: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0133: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0143: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0153: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0163: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0173: EADDR7(STACK, (BP+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0104: EADDR7(DATA, SI); REGPTR = (unsigned char *)&AL; return pc;
  case 0114: EADDR7(DATA, SI); REGPTR = (unsigned char *)&CL; return pc;
  case 0124: EADDR7(DATA, SI); REGPTR = (unsigned char *)&DL; return pc;
  case 0134: EADDR7(DATA, SI); REGPTR = (unsigned char *)&BL; return pc;
  case 0144: EADDR7(DATA, SI); REGPTR = (unsigned char *)&AH; return pc;
  case 0154: EADDR7(DATA, SI); REGPTR = (unsigned char *)&CH; return pc;
  case 0164: EADDR7(DATA, SI); REGPTR = (unsigned char *)&DH; return pc;
  case 0174: EADDR7(DATA, SI); REGPTR = (unsigned char *)&BH; return pc;

  case 0105: EADDR7(DATA, DI); REGPTR = (unsigned char *)&AL; return pc;
  case 0115: EADDR7(DATA, DI); REGPTR = (unsigned char *)&CL; return pc;
  case 0125: EADDR7(DATA, DI); REGPTR = (unsigned char *)&DL; return pc;
  case 0135: EADDR7(DATA, DI); REGPTR = (unsigned char *)&BL; return pc;
  case 0145: EADDR7(DATA, DI); REGPTR = (unsigned char *)&AH; return pc;
  case 0155: EADDR7(DATA, DI); REGPTR = (unsigned char *)&CH; return pc;
  case 0165: EADDR7(DATA, DI); REGPTR = (unsigned char *)&DH; return pc;
  case 0175: EADDR7(DATA, DI); REGPTR = (unsigned char *)&BH; return pc;

  case 0106: EADDR7(STACK, BP); REGPTR = (unsigned char *)&AL; return pc;
  case 0116: EADDR7(STACK, BP); REGPTR = (unsigned char *)&CL; return pc;
  case 0126: EADDR7(STACK, BP); REGPTR = (unsigned char *)&DL; return pc;
  case 0136: EADDR7(STACK, BP); REGPTR = (unsigned char *)&BL; return pc;
  case 0146: EADDR7(STACK, BP); REGPTR = (unsigned char *)&AH; return pc;
  case 0156: EADDR7(STACK, BP); REGPTR = (unsigned char *)&CH; return pc;
  case 0166: EADDR7(STACK, BP); REGPTR = (unsigned char *)&DH; return pc;
  case 0176: EADDR7(STACK, BP); REGPTR = (unsigned char *)&BH; return pc;

  case 0107: EADDR7(DATA, BX); REGPTR = (unsigned char *)&AL; return pc;
  case 0117: EADDR7(DATA, BX); REGPTR = (unsigned char *)&CL; return pc;
  case 0127: EADDR7(DATA, BX); REGPTR = (unsigned char *)&DL; return pc;
  case 0137: EADDR7(DATA, BX); REGPTR = (unsigned char *)&BL; return pc;
  case 0147: EADDR7(DATA, BX); REGPTR = (unsigned char *)&AH; return pc;
  case 0157: EADDR7(DATA, BX); REGPTR = (unsigned char *)&CH; return pc;
  case 0167: EADDR7(DATA, BX); REGPTR = (unsigned char *)&DH; return pc;
  case 0177: EADDR7(DATA, BX); REGPTR = (unsigned char *)&BH; return pc;
/*
 * 16-bit displacements
 */
  case 0200: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0210: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0220: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0230: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0240: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0250: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0260: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0270: EADDR6(DATA, (BX+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0201: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0211: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0221: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0231: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0241: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0251: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0261: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0271: EADDR6(DATA, (BX+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0202: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0212: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0222: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0232: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0242: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0252: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0262: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0272: EADDR6(STACK, (BP+SI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0203: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&AL; return pc;
  case 0213: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&CL; return pc;
  case 0223: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&DL; return pc;
  case 0233: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&BL; return pc;
  case 0243: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&AH; return pc;
  case 0253: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&CH; return pc;
  case 0263: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&DH; return pc;
  case 0273: EADDR6(STACK, (BP+DI)); REGPTR = (unsigned char *)&BH; return pc;

  case 0204: EADDR6(DATA, SI); REGPTR = (unsigned char *)&AL; return pc;
  case 0214: EADDR6(DATA, SI); REGPTR = (unsigned char *)&CL; return pc;
  case 0224: EADDR6(DATA, SI); REGPTR = (unsigned char *)&DL; return pc;
  case 0234: EADDR6(DATA, SI); REGPTR = (unsigned char *)&BL; return pc;
  case 0244: EADDR6(DATA, SI); REGPTR = (unsigned char *)&AH; return pc;
  case 0254: EADDR6(DATA, SI); REGPTR = (unsigned char *)&CH; return pc;
  case 0264: EADDR6(DATA, SI); REGPTR = (unsigned char *)&DH; return pc;
  case 0274: EADDR6(DATA, SI); REGPTR = (unsigned char *)&BH; return pc;

  case 0205: EADDR6(DATA, DI); REGPTR = (unsigned char *)&AL; return pc;
  case 0215: EADDR6(DATA, DI); REGPTR = (unsigned char *)&CL; return pc;
  case 0225: EADDR6(DATA, DI); REGPTR = (unsigned char *)&DL; return pc;
  case 0235: EADDR6(DATA, DI); REGPTR = (unsigned char *)&BL; return pc;
  case 0245: EADDR6(DATA, DI); REGPTR = (unsigned char *)&AH; return pc;
  case 0255: EADDR6(DATA, DI); REGPTR = (unsigned char *)&CH; return pc;
  case 0265: EADDR6(DATA, DI); REGPTR = (unsigned char *)&DH; return pc;
  case 0275: EADDR6(DATA, DI); REGPTR = (unsigned char *)&BH; return pc;

  case 0206: EADDR6(STACK, BP); REGPTR = (unsigned char *)&AL; return pc;
  case 0216: EADDR6(STACK, BP); REGPTR = (unsigned char *)&CL; return pc;
  case 0226: EADDR6(STACK, BP); REGPTR = (unsigned char *)&DL; return pc;
  case 0236: EADDR6(STACK, BP); REGPTR = (unsigned char *)&BL; return pc;
  case 0246: EADDR6(STACK, BP); REGPTR = (unsigned char *)&AH; return pc;
  case 0256: EADDR6(STACK, BP); REGPTR = (unsigned char *)&CH; return pc;
  case 0266: EADDR6(STACK, BP); REGPTR = (unsigned char *)&DH; return pc;
  case 0276: EADDR6(STACK, BP); REGPTR = (unsigned char *)&BH; return pc;

  case 0207: EADDR6(DATA, BX); REGPTR = (unsigned char *)&AL; return pc;
  case 0217: EADDR6(DATA, BX); REGPTR = (unsigned char *)&CL; return pc;
  case 0227: EADDR6(DATA, BX); REGPTR = (unsigned char *)&DL; return pc;
  case 0237: EADDR6(DATA, BX); REGPTR = (unsigned char *)&BL; return pc;
  case 0247: EADDR6(DATA, BX); REGPTR = (unsigned char *)&AH; return pc;
  case 0257: EADDR6(DATA, BX); REGPTR = (unsigned char *)&CH; return pc;
  case 0267: EADDR6(DATA, BX); REGPTR = (unsigned char *)&DH; return pc;
  case 0277: EADDR6(DATA, BX); REGPTR = (unsigned char *)&BH; return pc;
/*
 * Register direct
 */
  case 0300: EADDR8(AL,0); REGPTR = (unsigned char *)&AL; return pc;
  case 0310: EADDR8(AL,0); REGPTR = (unsigned char *)&CL; return pc;
  case 0320: EADDR8(AL,0); REGPTR = (unsigned char *)&DL; return pc;
  case 0330: EADDR8(AL,0); REGPTR = (unsigned char *)&BL; return pc;
  case 0340: EADDR8(AL,0); REGPTR = (unsigned char *)&AH; return pc;
  case 0350: EADDR8(AL,0); REGPTR = (unsigned char *)&CH; return pc;
  case 0360: EADDR8(AL,0); REGPTR = (unsigned char *)&DH; return pc;
  case 0370: EADDR8(AL,0); REGPTR = (unsigned char *)&BH; return pc;

  case 0301: EADDR8(CL,1); REGPTR = (unsigned char *)&AL; return pc;
  case 0311: EADDR8(CL,1); REGPTR = (unsigned char *)&CL; return pc;
  case 0321: EADDR8(CL,1); REGPTR = (unsigned char *)&DL; return pc;
  case 0331: EADDR8(CL,1); REGPTR = (unsigned char *)&BL; return pc;
  case 0341: EADDR8(CL,1); REGPTR = (unsigned char *)&AH; return pc;
  case 0351: EADDR8(CL,1); REGPTR = (unsigned char *)&CH; return pc;
  case 0361: EADDR8(CL,1); REGPTR = (unsigned char *)&DH; return pc;
  case 0371: EADDR8(CL,1); REGPTR = (unsigned char *)&BH; return pc;

  case 0302: EADDR8(DL,2); REGPTR = (unsigned char *)&AL; return pc;
  case 0312: EADDR8(DL,2); REGPTR = (unsigned char *)&CL; return pc;
  case 0322: EADDR8(DL,2); REGPTR = (unsigned char *)&DL; return pc;
  case 0332: EADDR8(DL,2); REGPTR = (unsigned char *)&BL; return pc;
  case 0342: EADDR8(DL,2); REGPTR = (unsigned char *)&AH; return pc;
  case 0352: EADDR8(DL,2); REGPTR = (unsigned char *)&CH; return pc;
  case 0362: EADDR8(DL,2); REGPTR = (unsigned char *)&DH; return pc;
  case 0372: EADDR8(DL,2); REGPTR = (unsigned char *)&BH; return pc;

  case 0303: EADDR8(BL,3); REGPTR = (unsigned char *)&AL; return pc;
  case 0313: EADDR8(BL,3); REGPTR = (unsigned char *)&CL; return pc;
  case 0323: EADDR8(BL,3); REGPTR = (unsigned char *)&DL; return pc;
  case 0333: EADDR8(BL,3); REGPTR = (unsigned char *)&BL; return pc;
  case 0343: EADDR8(BL,3); REGPTR = (unsigned char *)&AH; return pc;
  case 0353: EADDR8(BL,3); REGPTR = (unsigned char *)&CH; return pc;
  case 0363: EADDR8(BL,3); REGPTR = (unsigned char *)&DH; return pc;
  case 0373: EADDR8(BL,3); REGPTR = (unsigned char *)&BH; return pc;

  case 0304: EADDR8(AH,4); REGPTR = (unsigned char *)&AL; return pc;
  case 0314: EADDR8(AH,4); REGPTR = (unsigned char *)&CL; return pc;
  case 0324: EADDR8(AH,4); REGPTR = (unsigned char *)&DL; return pc;
  case 0334: EADDR8(AH,4); REGPTR = (unsigned char *)&BL; return pc;
  case 0344: EADDR8(AH,4); REGPTR = (unsigned char *)&AH; return pc;
  case 0354: EADDR8(AH,4); REGPTR = (unsigned char *)&CH; return pc;
  case 0364: EADDR8(AH,4); REGPTR = (unsigned char *)&DH; return pc;
  case 0374: EADDR8(AH,4); REGPTR = (unsigned char *)&BH; return pc;

  case 0305: EADDR8(CH,5); REGPTR = (unsigned char *)&AL; return pc;
  case 0315: EADDR8(CH,5); REGPTR = (unsigned char *)&CL; return pc;
  case 0325: EADDR8(CH,5); REGPTR = (unsigned char *)&DL; return pc;
  case 0335: EADDR8(CH,5); REGPTR = (unsigned char *)&BL; return pc;
  case 0345: EADDR8(CH,5); REGPTR = (unsigned char *)&AH; return pc;
  case 0355: EADDR8(CH,5); REGPTR = (unsigned char *)&CH; return pc;
  case 0365: EADDR8(CH,5); REGPTR = (unsigned char *)&DH; return pc;
  case 0375: EADDR8(CH,5); REGPTR = (unsigned char *)&BH; return pc;

  case 0306: EADDR8(DH,6); REGPTR = (unsigned char *)&AL; return pc;
  case 0316: EADDR8(DH,6); REGPTR = (unsigned char *)&CL; return pc;
  case 0326: EADDR8(DH,6); REGPTR = (unsigned char *)&DL; return pc;
  case 0336: EADDR8(DH,6); REGPTR = (unsigned char *)&BL; return pc;
  case 0346: EADDR8(DH,6); REGPTR = (unsigned char *)&AH; return pc;
  case 0356: EADDR8(DH,6); REGPTR = (unsigned char *)&CH; return pc;
  case 0366: EADDR8(DH,6); REGPTR = (unsigned char *)&DH; return pc;
  case 0376: EADDR8(DH,6); REGPTR = (unsigned char *)&BH; return pc;

  case 0307: EADDR8(BH,7); REGPTR = (unsigned char *)&AL; return pc;
  case 0317: EADDR8(BH,7); REGPTR = (unsigned char *)&CL; return pc;
  case 0327: EADDR8(BH,7); REGPTR = (unsigned char *)&DL; return pc;
  case 0337: EADDR8(BH,7); REGPTR = (unsigned char *)&BL; return pc;
  case 0347: EADDR8(BH,7); REGPTR = (unsigned char *)&AH; return pc;
  case 0357: EADDR8(BH,7); REGPTR = (unsigned char *)&CH; return pc;
  case 0367: EADDR8(BH,7); REGPTR = (unsigned char *)&DH; return pc;
  case 0377: EADDR8(BH,7); REGPTR = (unsigned char *)&BH; return pc;

  }
  return pc;
}