do {
		switch (mem[Pc++]) {
		case 0x00:
			PCINC;
			push(high(Pc));
			push(low(Pc));
			B = 1;
			push(get_status());
			Pc = join(mem[0xFFFE], mem[0xFFFF]);
			break;

		case 0x01:
			INDX;
			A |= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x02:
			break;

		case 0x03:
			break;

		case 0x04:
			break;

		case 0x05:
			A |= rZEROP;
			SIGN(A);
			ZERO(A);
			break;

		case 0x06:
			ZEROP;
			val = REFzero << 1;
			CARRY(val);
			val &= 0xFF;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x07:
			break;

		case 0x08:
			push(get_status());
			break;

		case 0x09:
			A |= REFimm;
			SIGN(A);
			ZERO(A);
			break;

		case 0x0A:
			A = A << 1;
			CARRY(A);
			A &= 0xFF;
			SIGN(A);
			ZERO(A);
			break;

		case 0x0B:
			break;

		case 0x0C:
			break;

		case 0x0D:
			ABSOL;
			A |= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x0E:
			ABSOL;
			val = REFptr << 1;
			CARRY(val);
			val &= 0xFF;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x0F:
			break;

		case 0x10:
			if (N) {
				PCINC;
			} else {
				BRANCH();
			}
			break;

		case 0x11:
			INDY;
			A |= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x12:
			break;

		case 0x13:
			break;

		case 0x14:
			break;

		case 0x15:
			A |= rZEROX;
			SIGN(A);
			ZERO(A);
			break;

		case 0x16:
			ZEROX;
			val = REFzero << 1;
			CARRY(val);
			val &= 0xFF;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x17:
			break;

		case 0x18:
			C = 0;
			break;

		case 0x19:
			ABSY;
			A |= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x1A:
			break;

		case 0x1C:
			break;

		case 0x1D:
			ABSX;
			A |= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x1E:
			ABSX;
			val = REFptr << 1;
			CARRY(val);
			val &= 0xFF;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x1F:
			break;

		case 0x20:
			ptmp = REFimm;
			ptmp |= mem[Pc] << 8;
			push(high(Pc));
			push(low(Pc));
			Pc = ptmp;

			if (jmp_tbl[Pc])
				jump(jmp_tbl[Pc]);
			break;

		case 0x21:
			INDX;
			A &= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x22:
			break;

		case 0x23:
			break;

		case 0x24:
			tmp = rZEROP;
			ZERO(A & tmp);
			N = tmp & 0x80;
			V = tmp & 0x40;
			break;

		case 0x25:
			A &= rZEROP;
			SIGN(A);
			ZERO(A);
			break;

		case 0x26:
			ZEROP;
			val = REFzero;
			tmp = C;
			val = val << 1;
			CARRY(val);
			val = (val & 0xFF) | tmp;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x27:
			break;

		case 0x28:
			put_status(pop());
			break;

		case 0x29:
			A &= REFimm;
			SIGN(A);
			ZERO(A);
			break;

		case 0x2A:
			tmp = C;
			A = A << 1;
			CARRY(A);
			A = (A & 0xFF) | tmp;
			SIGN(A);
			ZERO(A);
			break;

		case 0x2B:
			break;

		case 0x2C:
			ABSOL;
			tmp = REFptr;
			ZERO(A & tmp);
			N = tmp & 0x80;
			V = tmp & 0x40;
			break;

		case 0x2D:
			ABSOL;
			A &= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x2E:
			ABSOL;
			val = REFptr;
			tmp = C;
			val = val << 1;
			CARRY(val);
			val = (val & 0xFF) | tmp;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x2F:
			break;

		case 0x30:
			if (N) {
				BRANCH();
			} else{
				PCINC;
			}
			break;

		case 0x31:
			INDY;
			A &= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x32:
			break;

		case 0x33:
			break;

		case 0x34:
			break;

		case 0x35:
			A &= rZEROX;
			SIGN(A);
			ZERO(A);
			break;

		case 0x36:
			ZEROX;
			val = REFzero;
			tmp = C;
			val = val << 1;
			CARRY(val);
			val = (val & 0xFF) | tmp;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x37:
			break;

		case 0x38:
			C = 1;
			break;

		case 0x39:
			ABSY;
			A &= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x3A:
			break;

		case 0x3B:
			break;

		case 0x3C:
			break;

		case 0x3D:
			ABSX;
			A &= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x3E:
			ABSX;
			val = REFptr;
			tmp = C;
			val = val << 1;
			CARRY(val);
			val = (val & 0xFF) | tmp;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x3F:
			break;

		case 0x40:
			put_status(pop());
			Pc = pop();
			Pc |= pop() << 8;
			break;

		case 0x41:
			INDX;
			A ^= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x42:
			break;

		case 0x43:
			break;

		case 0x44:
			break;

		case 0x45:
			A ^= rZEROP;
			SIGN(A);
			ZERO(A);
			break;

		case 0x46:
			ZEROP;
			tmp = REFzero;
			C = (tmp & 0x01);
			tmp = tmp >> 1;
			SETzero(tmp);
			N = 0;
			ZERO(tmp);
			break;

		case 0x47:
			break;

		case 0x48:
			push(A);
			break;

		case 0x49:
			A ^= REFimm;
			SIGN(A);
			ZERO(A);
			break;

		case 0x4A:
			C = (A & 0x01);
			A = A >> 1;
			N = 0;
			ZERO(A);
			break;

		case 0x4B:
			break;

		case 0x4C:
			ptmp = REFimm;
			ptmp |= REFimm << 8;
			Pc = ptmp;

			if (jmp_tbl[Pc])
				jump(jmp_tbl[Pc]);
			break;

		case 0x4D:
			ABSOL;
			A ^= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x4E:
			ABSOL;
			tmp = REFptr;
			C = (tmp & 0x01);
			tmp = tmp >> 1;
			SETptr(tmp);
			N = 0;
			ZERO(tmp);
			break;

		case 0x4F:
			break;

		case 0x50:
			if (V) {
				PCINC;
			} else {
				BRANCH();
			}
			break;

		case 0x51:
			INDY;
			A ^= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x52:
			break;

		case 0x53:
			break;

		case 0x54:
			break;

		case 0x55:
			A ^= rZEROX;
			SIGN(A);
			ZERO(A);
			break;

		case 0x56:
			ZEROX;
			tmp = REFzero;
			C = (tmp & 0x01);
			tmp = tmp >> 1;
			SETzero(tmp);
			N = 0;
			ZERO(tmp);
			break;

		case 0x57:
			break;

		case 0x58:
			I = 0;
			break;

		case 0x59:
			ABSY;
			A ^= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x5A:
			break;

		case 0x5B:
			break;

		case 0x5C:
			break;

		case 0x5D:
			ABSX;
			A ^= REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0x5E:
			ABSX;
			tmp = REFptr;
			C = (tmp & 0x01);
			tmp = tmp >> 1;
			SETptr(tmp);
			N = 0;
			ZERO(tmp);
			break;

		case 0x5F:
			break;

		case 0x60:
			DO_RTS;
			break;

		case 0x61:
			INDX;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x62:
			break;

		case 0x63:
			break;

		case 0x64:
			break;

		case 0x65:
			val = rZEROP;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;


		case 0x66:
			ZEROP;
			val = REFzero;
			tmp = C;
			C = val & 0x01;
			val = val >> 1;
			val |= tmp << 7;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x67:
			break;

		case 0x68:
			A = pop();
			SIGN(A);
			ZERO(A);
			break;

		case 0x69:
			val = REFimm;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x6A:
			tmp = C;
			C = A & 0x01;
			A = A >> 1;
			A |= tmp << 7;
			SIGN(A);
			ZERO(A);
			break;

		case 0x6B:
			break;

		case 0x6C:
			ptmp = REFimm;
			ptmp |= REFimm << 8;
			Pc = mem[ptmp++];
			Pc |= mem[ptmp] << 8;

			if (jmp_tbl[Pc])
				jump(jmp_tbl[Pc]);
			break;

		case 0x6D:
			ABSOL;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x6E:
			ABSOL;
			val = REFptr;
			tmp = C;
			C = val & 0x01;
			val = val >> 1;
			val |= tmp << 7;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x6F:
			break;

		case 0x70:
			if (V) {
				BRANCH();
			} else {
				PCINC;
			}
			break;

		case 0x71:
			INDY;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x72:
			break;

		case 0x73:
			break;

		case 0x74:
			break;

		case 0x75:
			val = rZEROX;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x76:
			ZEROX;
			val = REFzero;
			tmp = C;
			C = val & 0x01;
			val = val >> 1;
			val |= tmp << 7;
			SETzero(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x77:
			break;

		case 0x78:
			I = 1;
			break;

		case 0x79:
			ABSY;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x7A:
			break;

		case 0x7B:
			break;

		case 0x7C:
			break;

		case 0x7D:
			ABSX;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				num = tobinary(val);
				val = tobinary(A);

				val += num + C;
				dCARRY(val);
				while (val >= 100)
					val -= 100;

				A = tobcd(val);
			} else {
				A += val + C;
				CARRY(A);
				A &= 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp == stmp) && (tmp != N);
			break;

		case 0x7E:
			ABSX;
			val = REFptr;
			tmp = C;
			C = val & 0x01;
			val = val >> 1;
			val |= tmp << 7;
			SETptr(val);
			SIGN(val);
			ZERO(val);
			break;

		case 0x7F:
			break;

		case 0x80:
			break;

		case 0x81:
			INDX;
			SETptr(A);
			break;

		case 0x82:
			break;

		case 0x83:
			break;

		case 0x84:
			sZEROP(Y);
			break;

		case 0x85:
			sZEROP(A);
			break;

		case 0x86:
			sZEROP(X);
			break;

		case 0x87:
			break;

		case 0x88:
			Y--;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0x89:
			break;

		case 0x8A:
			A = X;
			SIGN(A);
			ZERO(A);
			break;

		case 0x8B:
			break;

		case 0x8C:
			ABSOL;
			SETptr(Y);
			break;

		case 0x8D:
			ABSOL;
			SETptr(A);
			break;

		case 0x8E:
			ABSOL;
			SETptr(X);
			break;

		case 0x8F:
			break;

		case 0x90:
			if (C) {
				PCINC;
			} else {
				BRANCH();
			}
			break;

		case 0x91:
			INDY;
			SETptr(A);
			break;

		case 0x92:
			break;

		case 0x93:
			break;

		case 0x94:
			sZEROX(Y);
			break;

		case 0x95:
			sZEROX(A);
			break;

		case 0x96:
			sZEROY(X);
			break;

		case 0x97:
			break;

		case 0x98:
			A = Y;
			SIGN(A);
			ZERO(A);
			break;

		case 0x99:
			ABSY;
			SETptr(A);
			break;

		case 0x9A:
			Sp = X;
			break;

		case 0x9B:
			break;

		case 0x9C:
			break;

		case 0x9D:
			ABSX;
			SETptr(A);
			break;

		case 0x9E:
			break;

		case 0x9F:
			break;

		case 0xA0:
			Y = REFimm;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xA1:
			INDX;
			A = REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0xA2:
			X = REFimm;
			SIGN(X);
			ZERO(X);
			break;

		case 0xA3:
			break;

		case 0xA4:
			Y = rZEROP;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xA5:
			A = rZEROP;
			SIGN(A);
			ZERO(A);
			break;

		case 0xA6:
			X = rZEROP;
			SIGN(X);
			ZERO(X);
			break;

		case 0xA7:
			break;

		case 0xA8:
			Y = A;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xA9:
			A = REFimm;
			SIGN(A);
			ZERO(A);
			break;

		case 0xAA:
			X = A;
			SIGN(X);
			ZERO(X);
			break;

		case 0xAB:
			break;

		case 0xAC:
			ABSOL;
			Y = REFptr;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xAD:
			ABSOL;
			A = REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0xAE:
			ABSOL;
			X = REFptr;
			SIGN(X);
			ZERO(X);
			break;

		case 0xAF:
			break;

		case 0xB0:
			if (C) {
				BRANCH();
			} else {
				PCINC;
			}
			break;

		case 0xB1:
			INDY;
			A = REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0xB2:
			break;

		case 0xB3:
			break;

		case 0xB4:
			Y = rZEROX;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xB5:
			A = rZEROX;
			SIGN(A);
			ZERO(A);
			break;

		case 0xB6:
			X = rZEROY;
			SIGN(X);
			ZERO(X);
			break;

		case 0xB7:
			break;

		case 0xB8:
			V = 0;
			break;

		case 0xB9:
			ABSY;
			A = REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0xBA:
			X = Sp;
			SIGN(X);
			ZERO(X);
			break;

		case 0xBB:
			break;

		case 0xBC:
			ABSX;
			Y = REFptr;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xBD:
			ABSX;
			A = REFptr;
			SIGN(A);
			ZERO(A);
			break;

		case 0xBE:
			ABSY;
			X = REFptr;
			SIGN(X);
			ZERO(X);
			break;

		case 0xBF:
			break;

		case 0xC0:
			tmp = REFimm;
			C = (Y >= tmp);
			tmp = (Y - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xC1:
			INDX;
			tmp = REFptr;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xC2:
			break;

		case 0xC3:
			break;

		case 0xC4:
			tmp = rZEROP;
			C = (Y >= tmp);
			tmp = (Y - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xC5:
			tmp = rZEROP;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xC6:
			ZEROP;
			stmp = REFzero - 1;
			SETzero(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xC7:
			break;

		case 0xC8:
			Y++;
			SIGN(Y);
			ZERO(Y);
			break;

		case 0xC9:
			tmp = REFimm;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xCA:
			X--;
			SIGN(X);
			ZERO(X);
			break;

		case 0xCB:
			break;

		case 0xCC:
			ABSOL;
			tmp = REFptr;
			C = (Y >= tmp);
			tmp = (Y - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xCD:
			ABSOL;
			tmp = REFptr;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xCE:
			ABSOL;
			stmp = REFptr - 1;
			SETptr(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xCF:
			break;

		case 0xD0:
			if (NZ) {
				BRANCH();
			} else {
				PCINC;
			}
			break;

		case 0xD1:
			INDY;
			tmp = REFptr;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xD2:
			break;

		case 0xD3:
			break;

		case 0xD4:
			break;

		case 0xD5:
			tmp = rZEROX;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xD6:
			ZEROX;
			stmp = REFzero - 1;
			SETzero(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xD7:
			break;

		case 0xD8:
			D = 0;
			break;

		case 0xD9:
			ABSY;
			tmp = REFptr;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xDA:
			break;

		case 0xDB:
			break;

		case 0xDC:
			break;

		case 0xDD:
			ABSX;
			tmp = REFptr;
			C = (A >= tmp);
			tmp = (A - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xDE:
			ABSX;
			stmp = REFptr - 1;
			SETptr(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xDF:
			break;

		case 0xE0:
			tmp = REFimm;
			C = (X >= tmp);
			tmp = (X - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xE1:
			INDX;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xE2:
			break;

		case 0xE3:
			break;

		case 0xE4:
			tmp = rZEROP;
			C = (X >= tmp);
			tmp = (X - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xE5:
			val = rZEROP;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xE6:
			ZEROP;
			stmp = REFzero + 1;
			SIGN(stmp);
			ZERO(stmp);
			SETzero(stmp);
			break;

		case 0xE7:
			break;

		case 0xE8:
			X++;
			SIGN(X);
			ZERO(X);
			break;

		case 0xE9:
			val = REFimm;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xEA:
			break;

		case 0xEB:
			break;

		case 0xEC:
			ABSOL;
			tmp = REFptr;
			C = (X >= tmp);
			tmp = (X - tmp) & 0xFF;
			SIGN(tmp);
			ZERO(tmp);
			break;

		case 0xED:
			ABSOL;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xEE:
			ABSOL;
			stmp = REFptr + 1;
			SETptr(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xEF:
			break;

		case 0xF0:
			if (NZ) {
				PCINC;
			} else {
				BRANCH();
			}
			break;

		case 0xF1:
			INDY;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xF2:
			break;

		case 0xF3:
			break;

		case 0xF4:
			break;

		case 0xF5:
			val = rZEROX;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xF6:
			ZEROX;
			stmp = REFzero + 1;
			SETzero(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xF7:
			break;

		case 0xF8:
			D = 1;
			break;

		case 0xF9:
			ABSY;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xFA:
			break;

		case 0xFB:
			break;

		case 0xFC:
			break;

		case 0xFD:
			ABSX;
			val = REFptr;
			tmp = A & 0x80;
			stmp = val & 0x80;
			if (D) {
				assert(FALSE);
			} else {
				foo = A - (val + !C);
				C = (foo >= 0);
				A = foo & 0xFF;
			}
			ZERO(A);
			SIGN(A);
			V = (tmp != stmp) && (tmp != N);
			break;

		case 0xFE:
			ABSX;
			stmp = REFptr + 1;
			SETptr(stmp);
			SIGN(stmp);
			ZERO(stmp);
			break;

		case 0xFF:
			break;
		}
	} while (running);