uxn

Varvara Ordinator, written in ANSI C(SDL2)
git clone https://git.eamoncaddigan.net/uxn.git
Log | Files | Refs | README | LICENSE
commit 6337990fe016a4135812670814e13d4996db84af
parent 4f6a29f57d19256d31854d177a4fdbd1fcbfedca
Author: Andrew Alderwick <andrew@alderwick.co.uk>
Date:   Mon, 30 Aug 2021 18:45:04 +0100

Reverted flags in uxn-fast.c

Diffstat:

Msrc/uxn-fast.c | 1903+++++++++++++++++++++++++++++++++++++++----------------------------------------


1 file changed, 951 insertions(+), 952 deletions(-)

diff --git a/src/uxn-fast.c b/src/uxn-fast.c
@@ -22,8 +22,7 @@ See etc/mkuxn-fast.moon for instructions.
 
 */
 
-#define MODE_RETURN 0x20
-#define MODE_SHORT 0x40
+#define MODE_RETURN 0x40
 #define MODE_KEEP 0x80
 
 #pragma mark - Operations
@@ -501,935 +500,935 @@ uxn_eval(Uxn *u, Uint16 vec)
 				u->wst.ptr -= 1;
 			}
 			break;
-		case 0x20: /* LITr */
-		case 0xa0: /* LITkr */
+		case 0x20: /* LIT2 */
+		case 0xa0: /* LIT2k */
 			{
-				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
+				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, u->ram.ptr++);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0x21: /* INCr */
+		case 0x21: /* INC2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 1] = a + 1;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->wst.dat[u->wst.ptr - 2] = (a + 1) >> 8;
+				u->wst.dat[u->wst.ptr - 1] = (a + 1) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x22: /* POPr */
+		case 0x22: /* POP2 */
 			{
-				u->rst.dat[u->rst.ptr - 1];
+				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x23: /* DUPr */
+		case 0x23: /* DUP2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b;
+				u->wst.dat[u->wst.ptr + 1] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0x24: /* NIPr */
+		case 0x24: /* NIP2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				(u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = a >> 8;
+				u->wst.dat[u->wst.ptr - 3] = a & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x25: /* SWPr */
+		case 0x25: /* SWP2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = a;
-				u->rst.dat[u->rst.ptr - 1] = b;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr - 4] = b;
+				u->wst.dat[u->wst.ptr - 3] = a;
+				u->wst.dat[u->wst.ptr - 2] = d;
+				u->wst.dat[u->wst.ptr - 1] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x26: /* OVRr */
+		case 0x26: /* OVR2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = d;
+				u->wst.dat[u->wst.ptr + 1] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0x27: /* ROTr */
+		case 0x27: /* ROT2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
-				u->rst.dat[u->rst.ptr - 3] = b;
-				u->rst.dat[u->rst.ptr - 2] = a;
-				u->rst.dat[u->rst.ptr - 1] = c;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
+				u->wst.dat[u->wst.ptr - 6] = d;
+				u->wst.dat[u->wst.ptr - 5] = c;
+				u->wst.dat[u->wst.ptr - 4] = b;
+				u->wst.dat[u->wst.ptr - 3] = a;
+				u->wst.dat[u->wst.ptr - 2] = f;
+				u->wst.dat[u->wst.ptr - 1] = e;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 3, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 6, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x28: /* EQUr */
+		case 0x28: /* EQU2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b == a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = b == a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x29: /* NEQr */
+		case 0x29: /* NEQ2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b != a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = b != a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x2a: /* GTHr */
+		case 0x2a: /* GTH2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b > a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = b > a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x2b: /* LTHr */
+		case 0x2b: /* LTH2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b < a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = b < a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x2c: /* JMPr */
+		case 0x2c: /* JMP2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->ram.ptr += (Sint8)a;
+				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x2d: /* JCNr */
+		case 0x2d: /* JCN2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (Sint8)a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 2;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x2e: /* JSRr */
+		case 0x2e: /* JSR2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
-				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
-				u->ram.ptr += (Sint8)a;
+				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
+				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0x2f: /* STHr */
+		case 0x2f: /* STH2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b;
+				u->rst.dat[u->rst.ptr + 1] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0x30: /* LDZr */
+		case 0x30: /* LDZ2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, a);
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0x31: /* STZr */
+		case 0x31: /* STZ2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				Uint8 b = u->rst.dat[u->rst.ptr - 2];
-				poke8(u->ram.dat, a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				poke16(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 2;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x32: /* LDRr */
+		case 0x32: /* LDR2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0x33: /* STRr */
+		case 0x33: /* STR2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				Uint8 b = u->rst.dat[u->rst.ptr - 2];
-				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 2;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x34: /* LDAr */
+		case 0x34: /* LDA2 */
 			{
-				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
-				u->rst.dat[u->rst.ptr - 2] = peek8(u->ram.dat, a);
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->wst.dat[u->wst.ptr - 2] = peek8(u->ram.dat, a);
+				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x35: /* STAr */
+		case 0x35: /* STA2 */
 			{
-				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
-				Uint8 b = u->rst.dat[u->rst.ptr - 3];
-				poke8(u->ram.dat, a, b);
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				poke16(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 3, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 3;
+				u->wst.ptr -= 4;
 			}
 			break;
-		case 0x36: /* DEIr */
+		case 0x36: /* DEI2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 1] = devr8(&u->dev[a >> 4], a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 1] = devr8(&u->dev[a >> 4], a);
+				u->wst.dat[u->wst.ptr] = devr8(&u->dev[a >> 4], a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0x37: /* DEOr */
+		case 0x37: /* DEO2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				devw8(&u->dev[a >> 4], a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				devw16(&u->dev[a >> 4], a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 2;
+				u->wst.ptr -= 3;
 			}
 			break;
-		case 0x38: /* ADDr */
+		case 0x38: /* ADD2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b + a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = (b + a) >> 8;
+				u->wst.dat[u->wst.ptr - 3] = (b + a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x39: /* SUBr */
+		case 0x39: /* SUB2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b - a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = (b - a) >> 8;
+				u->wst.dat[u->wst.ptr - 3] = (b - a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3a: /* MULr */
+		case 0x3a: /* MUL2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b * a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr - 4] = (b * a) >> 8;
+				u->wst.dat[u->wst.ptr - 3] = (b * a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3b: /* DIVr */
+		case 0x3b: /* DIV2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
 				if(a == 0) {
-					u->rst.error = 3;
+					u->wst.error = 3;
 #ifndef NO_STACK_CHECKS
 					goto error;
 #endif
 					a = 1;
 				}
-				u->rst.dat[u->rst.ptr - 2] = b / a;
+				u->wst.dat[u->wst.ptr - 4] = (b / a) >> 8;
+				u->wst.dat[u->wst.ptr - 3] = (b / a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3c: /* ANDr */
+		case 0x3c: /* AND2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b & a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr - 4] = d & b;
+				u->wst.dat[u->wst.ptr - 3] = c & a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3d: /* ORAr */
+		case 0x3d: /* ORA2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b | a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr - 4] = d | b;
+				u->wst.dat[u->wst.ptr - 3] = c | a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3e: /* EORr */
+		case 0x3e: /* EOR2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b ^ a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr - 4] = d ^ b;
+				u->wst.dat[u->wst.ptr - 3] = c ^ a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 2;
 			}
 			break;
-		case 0x3f: /* SFTr */
+		case 0x3f: /* SFT2 */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				u->wst.dat[u->wst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
+				u->wst.dat[u->wst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
-				u->rst.ptr -= 1;
+				u->wst.ptr -= 1;
 			}
 			break;
-		case 0x40: /* LIT2 */
-		case 0xc0: /* LIT2k */
+		case 0x40: /* LITr */
+		case 0xc0: /* LITkr */
 			{
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
-				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, u->ram.ptr++);
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0x41: /* INC2 */
+		case 0x41: /* INCr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				u->wst.dat[u->wst.ptr - 2] = (a + 1) >> 8;
-				u->wst.dat[u->wst.ptr - 1] = (a + 1) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = a + 1;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x42: /* POP2 */
+		case 0x42: /* POPr */
 			{
-				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr - 1];
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x43: /* DUP2 */
+		case 0x43: /* DUPr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
-				u->wst.dat[u->wst.ptr] = b;
-				u->wst.dat[u->wst.ptr + 1] = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0x44: /* NIP2 */
+		case 0x44: /* NIPr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				(u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = a >> 8;
-				u->wst.dat[u->wst.ptr - 3] = a & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x45: /* SWP2 */
+		case 0x45: /* SWPr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr - 4] = b;
-				u->wst.dat[u->wst.ptr - 3] = a;
-				u->wst.dat[u->wst.ptr - 2] = d;
-				u->wst.dat[u->wst.ptr - 1] = c;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = a;
+				u->rst.dat[u->rst.ptr - 1] = b;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x46: /* OVR2 */
+		case 0x46: /* OVRr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = d;
-				u->wst.dat[u->wst.ptr + 1] = c;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0x47: /* ROT2 */
+		case 0x47: /* ROTr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
-				u->wst.dat[u->wst.ptr - 6] = d;
-				u->wst.dat[u->wst.ptr - 5] = c;
-				u->wst.dat[u->wst.ptr - 4] = b;
-				u->wst.dat[u->wst.ptr - 3] = a;
-				u->wst.dat[u->wst.ptr - 2] = f;
-				u->wst.dat[u->wst.ptr - 1] = e;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
+				u->rst.dat[u->rst.ptr - 3] = b;
+				u->rst.dat[u->rst.ptr - 2] = a;
+				u->rst.dat[u->rst.ptr - 1] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 6, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0x48: /* EQU2 */
+		case 0x48: /* EQUr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = b == a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b == a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x49: /* NEQ2 */
+		case 0x49: /* NEQr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = b != a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b != a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x4a: /* GTH2 */
+		case 0x4a: /* GTHr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = b > a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b > a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x4b: /* LTH2 */
+		case 0x4b: /* LTHr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = b < a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b < a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x4c: /* JMP2 */
+		case 0x4c: /* JMPr */
 			{
-				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x4d: /* JCN2 */
+		case 0x4d: /* JCNr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 2;
 			}
 			break;
-		case 0x4e: /* JSR2 */
+		case 0x4e: /* JSRr */
 			{
-				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
-				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
-				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
+				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0x4f: /* STH2 */
+		case 0x4f: /* STHr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b;
-				u->rst.dat[u->rst.ptr + 1] = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0x50: /* LDZ2 */
+		case 0x50: /* LDZr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, a);
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
-					goto error;
-				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
 			}
 			break;
-		case 0x51: /* STZ2 */
+		case 0x51: /* STZr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				poke16(u->ram.dat, a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint8 b = u->rst.dat[u->rst.ptr - 2];
+				poke8(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 2;
 			}
 			break;
-		case 0x52: /* LDR2 */
+		case 0x52: /* LDRr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
-					goto error;
-				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
 			}
 			break;
-		case 0x53: /* STR2 */
+		case 0x53: /* STRr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint8 b = u->rst.dat[u->rst.ptr - 2];
+				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 2;
 			}
 			break;
-		case 0x54: /* LDA2 */
+		case 0x54: /* LDAr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				u->wst.dat[u->wst.ptr - 2] = peek8(u->ram.dat, a);
-				u->wst.dat[u->wst.ptr - 1] = peek8(u->ram.dat, a + 1);
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr - 2] = peek8(u->ram.dat, a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x55: /* STA2 */
+		case 0x55: /* STAr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				Uint16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				poke16(u->ram.dat, a, b);
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				Uint8 b = u->rst.dat[u->rst.ptr - 3];
+				poke8(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 4;
+				u->rst.ptr -= 3;
 			}
 			break;
-		case 0x56: /* DEI2 */
+		case 0x56: /* DEIr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr - 1] = devr8(&u->dev[a >> 4], a);
-				u->wst.dat[u->wst.ptr] = devr8(&u->dev[a >> 4], a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = devr8(&u->dev[a >> 4], a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
-					goto error;
-				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
 			}
 			break;
-		case 0x57: /* DEO2 */
+		case 0x57: /* DEOr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				devw16(&u->dev[a >> 4], a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				devw8(&u->dev[a >> 4], a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 3;
+				u->rst.ptr -= 2;
 			}
 			break;
-		case 0x58: /* ADD2 */
+		case 0x58: /* ADDr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = (b + a) >> 8;
-				u->wst.dat[u->wst.ptr - 3] = (b + a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b + a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x59: /* SUB2 */
+		case 0x59: /* SUBr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = (b - a) >> 8;
-				u->wst.dat[u->wst.ptr - 3] = (b - a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b - a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5a: /* MUL2 */
+		case 0x5a: /* MULr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr - 4] = (b * a) >> 8;
-				u->wst.dat[u->wst.ptr - 3] = (b * a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b * a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5b: /* DIV2 */
+		case 0x5b: /* DIVr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
 				if(a == 0) {
-					u->wst.error = 3;
+					u->rst.error = 3;
 #ifndef NO_STACK_CHECKS
 					goto error;
 #endif
 					a = 1;
 				}
-				u->wst.dat[u->wst.ptr - 4] = (b / a) >> 8;
-				u->wst.dat[u->wst.ptr - 3] = (b / a) & 0xff;
+				u->rst.dat[u->rst.ptr - 2] = b / a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5c: /* AND2 */
+		case 0x5c: /* ANDr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr - 4] = d & b;
-				u->wst.dat[u->wst.ptr - 3] = c & a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b & a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5d: /* ORA2 */
+		case 0x5d: /* ORAr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr - 4] = d | b;
-				u->wst.dat[u->wst.ptr - 3] = c | a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b | a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5e: /* EOR2 */
+		case 0x5e: /* EORr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr - 4] = d ^ b;
-				u->wst.dat[u->wst.ptr - 3] = c ^ a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b ^ a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 2;
+				u->rst.ptr -= 1;
 			}
 			break;
-		case 0x5f: /* SFT2 */
+		case 0x5f: /* SFTr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				u->wst.dat[u->wst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
-				u->wst.dat[u->wst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
-				u->wst.ptr -= 1;
+				u->rst.ptr -= 1;
 			}
 			break;
 		case 0x60: /* LIT2r */
@@ -2426,1049 +2425,1049 @@ uxn_eval(Uxn *u, Uint16 vec)
 				u->wst.ptr += 1;
 			}
 			break;
-		case 0xa1: /* INCkr */
+		case 0xa1: /* INC2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = a + 1;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->wst.dat[u->wst.ptr] = (a + 1) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (a + 1) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xa2: /* POPkr */
+		case 0xa2: /* POP2k */
 			{
-				u->rst.dat[u->rst.ptr - 1];
+				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xa3: /* DUPkr */
+		case 0xa3: /* DUP2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = a;
-				u->rst.dat[u->rst.ptr + 1] = a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b;
+				u->wst.dat[u->wst.ptr + 1] = a;
+				u->wst.dat[u->wst.ptr + 2] = b;
+				u->wst.dat[u->wst.ptr + 3] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 251, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 4;
 			}
 			break;
-		case 0xa4: /* NIPkr */
+		case 0xa4: /* NIP2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				(u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = a >> 8;
+				u->wst.dat[u->wst.ptr + 1] = a & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xa5: /* SWPkr */
+		case 0xa5: /* SWP2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = a;
-				u->rst.dat[u->rst.ptr + 1] = b;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = b;
+				u->wst.dat[u->wst.ptr + 1] = a;
+				u->wst.dat[u->wst.ptr + 2] = d;
+				u->wst.dat[u->wst.ptr + 3] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 251, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 4;
 			}
 			break;
-		case 0xa6: /* OVRkr */
+		case 0xa6: /* OVR2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b;
-				u->rst.dat[u->rst.ptr + 1] = a;
-				u->rst.dat[u->rst.ptr + 2] = b;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = d;
+				u->wst.dat[u->wst.ptr + 1] = c;
+				u->wst.dat[u->wst.ptr + 2] = b;
+				u->wst.dat[u->wst.ptr + 3] = a;
+				u->wst.dat[u->wst.ptr + 4] = d;
+				u->wst.dat[u->wst.ptr + 5] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 252, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 249, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 3;
+				u->wst.ptr += 6;
 			}
 			break;
-		case 0xa7: /* ROTkr */
+		case 0xa7: /* ROT2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
-				u->rst.dat[u->rst.ptr] = b;
-				u->rst.dat[u->rst.ptr + 1] = a;
-				u->rst.dat[u->rst.ptr + 2] = c;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
+				u->wst.dat[u->wst.ptr] = d;
+				u->wst.dat[u->wst.ptr + 1] = c;
+				u->wst.dat[u->wst.ptr + 2] = b;
+				u->wst.dat[u->wst.ptr + 3] = a;
+				u->wst.dat[u->wst.ptr + 4] = f;
+				u->wst.dat[u->wst.ptr + 5] = e;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 3, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 6, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 252, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 249, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 3;
+				u->wst.ptr += 6;
 			}
 			break;
-		case 0xa8: /* EQUkr */
+		case 0xa8: /* EQU2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b == a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = b == a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0xa9: /* NEQkr */
+		case 0xa9: /* NEQ2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b != a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = b != a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0xaa: /* GTHkr */
+		case 0xaa: /* GTH2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b > a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = b > a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0xab: /* LTHkr */
+		case 0xab: /* LTH2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b < a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = b < a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0xac: /* JMPkr */
+		case 0xac: /* JMP2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->ram.ptr += (Sint8)a;
+				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xad: /* JCNkr */
+		case 0xad: /* JCN2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (Sint8)a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xae: /* JSRkr */
+		case 0xae: /* JSR2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
-				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
-				u->ram.ptr += (Sint8)a;
+				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
+				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0xaf: /* STHkr */
+		case 0xaf: /* STH2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b;
+				u->rst.dat[u->rst.ptr + 1] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0xb0: /* LDZkr */
+		case 0xb0: /* LDZ2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a);
+				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xb1: /* STZkr */
+		case 0xb1: /* STZ2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				Uint8 b = u->rst.dat[u->rst.ptr - 2];
-				poke8(u->ram.dat, a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				poke16(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xb2: /* LDRkr */
+		case 0xb2: /* LDR2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
+				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xb3: /* STRkr */
+		case 0xb3: /* STR2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				Uint8 b = u->rst.dat[u->rst.ptr - 2];
-				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xb4: /* LDAkr */
+		case 0xb4: /* LDA2k */
 			{
-				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
-				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a);
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a);
+				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xb5: /* STAkr */
+		case 0xb5: /* STA2k */
 			{
-				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
-				Uint8 b = u->rst.dat[u->rst.ptr - 3];
-				poke8(u->ram.dat, a, b);
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				poke16(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 3, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xb6: /* DEIkr */
+		case 0xb6: /* DEI2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1];
-				u->rst.dat[u->rst.ptr] = devr8(&u->dev[a >> 4], a);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = devr8(&u->dev[a >> 4], a);
+				u->wst.dat[u->wst.ptr + 1] = devr8(&u->dev[a >> 4], a + 1);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 1, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xb7: /* DEOkr */
+		case 0xb7: /* DEO2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				devw8(&u->dev[a >> 4], a, b);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				devw16(&u->dev[a >> 4], a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xb8: /* ADDkr */
+		case 0xb8: /* ADD2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b + a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = (b + a) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (b + a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xb9: /* SUBkr */
+		case 0xb9: /* SUB2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b - a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = (b - a) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (b - a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xba: /* MULkr */
+		case 0xba: /* MUL2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b * a;
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				u->wst.dat[u->wst.ptr] = (b * a) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (b * a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xbb: /* DIVkr */
+		case 0xbb: /* DIV2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
 				if(a == 0) {
-					u->rst.error = 3;
+					u->wst.error = 3;
 #ifndef NO_STACK_CHECKS
 					goto error;
 #endif
 					a = 1;
 				}
-				u->rst.dat[u->rst.ptr] = b / a;
+				u->wst.dat[u->wst.ptr] = (b / a) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (b / a) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xbc: /* ANDkr */
+		case 0xbc: /* AND2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b & a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = d & b;
+				u->wst.dat[u->wst.ptr + 1] = c & a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xbd: /* ORAkr */
+		case 0xbd: /* ORA2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b | a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = d | b;
+				u->wst.dat[u->wst.ptr + 1] = c | a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xbe: /* EORkr */
+		case 0xbe: /* EOR2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b ^ a;
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
+				u->wst.dat[u->wst.ptr] = d ^ b;
+				u->wst.dat[u->wst.ptr + 1] = c ^ a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xbf: /* SFTkr */
+		case 0xbf: /* SFT2k */
 			{
-				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4);
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
+				u->wst.dat[u->wst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
+				u->wst.dat[u->wst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->rst.ptr < 2, 0)) {
-					u->rst.error = 1;
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 254, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 1;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xc1: /* INC2k */
+		case 0xc1: /* INCkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				u->wst.dat[u->wst.ptr] = (a + 1) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (a + 1) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a + 1;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xc2: /* POP2k */
+		case 0xc2: /* POPkr */
 			{
-				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr - 1];
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xc3: /* DUP2k */
+		case 0xc3: /* DUPkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
-				u->wst.dat[u->wst.ptr] = b;
-				u->wst.dat[u->wst.ptr + 1] = a;
-				u->wst.dat[u->wst.ptr + 2] = b;
-				u->wst.dat[u->wst.ptr + 3] = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a;
+				u->rst.dat[u->rst.ptr + 1] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 251, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 4;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0xc4: /* NIP2k */
+		case 0xc4: /* NIPkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				(u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = a >> 8;
-				u->wst.dat[u->wst.ptr + 1] = a & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xc5: /* SWP2k */
+		case 0xc5: /* SWPkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = b;
-				u->wst.dat[u->wst.ptr + 1] = a;
-				u->wst.dat[u->wst.ptr + 2] = d;
-				u->wst.dat[u->wst.ptr + 3] = c;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = a;
+				u->rst.dat[u->rst.ptr + 1] = b;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 251, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 4;
+				u->rst.ptr += 2;
 			}
 			break;
-		case 0xc6: /* OVR2k */
+		case 0xc6: /* OVRkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = d;
-				u->wst.dat[u->wst.ptr + 1] = c;
-				u->wst.dat[u->wst.ptr + 2] = b;
-				u->wst.dat[u->wst.ptr + 3] = a;
-				u->wst.dat[u->wst.ptr + 4] = d;
-				u->wst.dat[u->wst.ptr + 5] = c;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b;
+				u->rst.dat[u->rst.ptr + 1] = a;
+				u->rst.dat[u->rst.ptr + 2] = b;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 249, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 252, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 6;
+				u->rst.ptr += 3;
 			}
 			break;
-		case 0xc7: /* ROT2k */
+		case 0xc7: /* ROTkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
-				u->wst.dat[u->wst.ptr] = d;
-				u->wst.dat[u->wst.ptr + 1] = c;
-				u->wst.dat[u->wst.ptr + 2] = b;
-				u->wst.dat[u->wst.ptr + 3] = a;
-				u->wst.dat[u->wst.ptr + 4] = f;
-				u->wst.dat[u->wst.ptr + 5] = e;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
+				u->rst.dat[u->rst.ptr] = b;
+				u->rst.dat[u->rst.ptr + 1] = a;
+				u->rst.dat[u->rst.ptr + 2] = c;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 6, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 249, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 252, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 6;
+				u->rst.ptr += 3;
 			}
 			break;
-		case 0xc8: /* EQU2k */
+		case 0xc8: /* EQUkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = b == a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b == a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xc9: /* NEQ2k */
+		case 0xc9: /* NEQkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = b != a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b != a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xca: /* GTH2k */
+		case 0xca: /* GTHkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = b > a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b > a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xcb: /* LTH2k */
+		case 0xcb: /* LTHkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = b < a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b < a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 254, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 1;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xcc: /* JMP2k */
+		case 0xcc: /* JMPkr */
 			{
-				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xcd: /* JCN2k */
+		case 0xcd: /* JCNkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xce: /* JSR2k */
+		case 0xce: /* JSRkr */
 			{
-				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
-				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
-				u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
+				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr += (Sint8)a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 2;
 			}
 			break;
-		case 0xcf: /* STH2k */
+		case 0xcf: /* STHkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
-				u->rst.dat[u->rst.ptr] = b;
-				u->rst.dat[u->rst.ptr + 1] = a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->rst.ptr > 253, 0)) {
-					u->rst.error = 2;
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
 					goto error;
 				}
 #endif
-				u->rst.ptr += 2;
+				u->wst.ptr += 1;
 			}
 			break;
-		case 0xd0: /* LDZ2k */
+		case 0xd0: /* LDZkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a);
-				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xd1: /* STZ2k */
+		case 0xd1: /* STZkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				poke16(u->ram.dat, a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint8 b = u->rst.dat[u->rst.ptr - 2];
+				poke8(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xd2: /* LDR2k */
+		case 0xd2: /* LDRkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
-				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xd3: /* STR2k */
+		case 0xd3: /* STRkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint8 b = u->rst.dat[u->rst.ptr - 2];
+				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xd4: /* LDA2k */
+		case 0xd4: /* LDAkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, a);
-				u->wst.dat[u->wst.ptr + 1] = peek8(u->ram.dat, a + 1);
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 2, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xd5: /* STA2k */
+		case 0xd5: /* STAkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
-				Uint16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				poke16(u->ram.dat, a, b);
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				Uint8 b = u->rst.dat[u->rst.ptr - 3];
+				poke8(u->ram.dat, a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xd6: /* DEI2k */
+		case 0xd6: /* DEIkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				u->wst.dat[u->wst.ptr] = devr8(&u->dev[a >> 4], a);
-				u->wst.dat[u->wst.ptr + 1] = devr8(&u->dev[a >> 4], a + 1);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = devr8(&u->dev[a >> 4], a);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 1, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xd7: /* DEO2k */
+		case 0xd7: /* DEOkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				devw16(&u->dev[a >> 4], a, b);
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				devw8(&u->dev[a >> 4], a, b);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
 #endif
 			}
 			break;
-		case 0xd8: /* ADD2k */
+		case 0xd8: /* ADDkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = (b + a) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (b + a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b + a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xd9: /* SUB2k */
+		case 0xd9: /* SUBkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = (b - a) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (b - a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b - a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xda: /* MUL2k */
+		case 0xda: /* MULkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
-				u->wst.dat[u->wst.ptr] = (b * a) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (b * a) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b * a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xdb: /* DIV2k */
+		case 0xdb: /* DIVkr */
 			{
-				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
 				if(a == 0) {
-					u->wst.error = 3;
+					u->rst.error = 3;
 #ifndef NO_STACK_CHECKS
 					goto error;
 #endif
 					a = 1;
 				}
-				u->wst.dat[u->wst.ptr] = (b / a) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (b / a) & 0xff;
+				u->rst.dat[u->rst.ptr] = b / a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xdc: /* AND2k */
+		case 0xdc: /* ANDkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = d & b;
-				u->wst.dat[u->wst.ptr + 1] = c & a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b & a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xdd: /* ORA2k */
+		case 0xdd: /* ORAkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = d | b;
-				u->wst.dat[u->wst.ptr + 1] = c | a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b | a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xde: /* EOR2k */
+		case 0xde: /* EORkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
-				u->wst.dat[u->wst.ptr] = d ^ b;
-				u->wst.dat[u->wst.ptr + 1] = c ^ a;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b ^ a;
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 4, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
-		case 0xdf: /* SFT2k */
+		case 0xdf: /* SFTkr */
 			{
-				Uint8 a = u->wst.dat[u->wst.ptr - 1];
-				Uint16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
-				u->wst.dat[u->wst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
-				u->wst.dat[u->wst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				u->rst.dat[u->rst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4);
 #ifndef NO_STACK_CHECKS
-				if(__builtin_expect(u->wst.ptr < 3, 0)) {
-					u->wst.error = 1;
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
 					goto error;
 				}
-				if(__builtin_expect(u->wst.ptr > 253, 0)) {
-					u->wst.error = 2;
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
 					goto error;
 				}
 #endif
-				u->wst.ptr += 2;
+				u->rst.ptr += 1;
 			}
 			break;
 		case 0xe1: /* INC2kr */