diff --git a/apps/plugin.h b/apps/plugin.h
index bd95331143..9ccfd250f0 100644
--- a/apps/plugin.h
+++ b/apps/plugin.h
@@ -7,7 +7,7 @@
  *                     \/            \/     \/    \/            \/
  * $Id$
  *
- * Copyright (C) 2002 Björn Stenberg
+ * Copyright (C) 2002 Bj�rn Stenberg
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/apps/plugins/CATEGORIES b/apps/plugins/CATEGORIES
index d3093689f9..bfb79dd6aa 100644
--- a/apps/plugins/CATEGORIES
+++ b/apps/plugins/CATEGORIES
@@ -189,3 +189,4 @@ wormlet,games
 xobox,games
 xworld,games
 zxbox,viewers
+varvara,apps
diff --git a/apps/plugins/SUBDIRS b/apps/plugins/SUBDIRS
index 8479e4b3dd..37b28f24d0 100644
--- a/apps/plugins/SUBDIRS
+++ b/apps/plugins/SUBDIRS
@@ -1,6 +1,7 @@
 /* For all targets */
 shortcuts
 text_viewer
+varvara
 
 /* For various targets... */
 
diff --git a/apps/plugins/helloworld.c b/apps/plugins/helloworld.c
deleted file mode 100644
index af55610c73..0000000000
--- a/apps/plugins/helloworld.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- * $Id$
- *
- * Copyright (C) 2002 Björn Stenberg
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ****************************************************************************/
-
-/* welcome to the example rockbox plugin */
-
-/* mandatory include for all plugins */
-#include "plugin.h"
-
-/* this is the plugin entry point */
-enum plugin_status plugin_start(const void* parameter)
-{
-    /* if you don't use the parameter, you can do like
-       this to avoid the compiler warning about it */
-    (void)parameter;
-
-    /* "rb->" marks a plugin api call. Rockbox offers many of its built-in
-     * functions to plugins */
-    /* now go ahead and have fun! */
-    rb->splash(HZ*2, "Hello world!");
-
-    /* tell Rockbox that we have completed successfully */
-    return PLUGIN_OK;
-}
diff --git a/apps/plugins/varvara/SOURCES b/apps/plugins/varvara/SOURCES
new file mode 100644
index 0000000000..84bc5c6964
--- /dev/null
+++ b/apps/plugins/varvara/SOURCES
@@ -0,0 +1,5 @@
+uxn.h
+uxn.c
+devices/ppu.h
+devices/ppu.c
+varvara.c
diff --git a/apps/plugins/varvara/console.tal b/apps/plugins/varvara/console.tal
new file mode 100644
index 0000000000..cbcbb56052
--- /dev/null
+++ b/apps/plugins/varvara/console.tal
@@ -0,0 +1,17 @@
+( dev/console )
+
+|10 @Console $8 &write
+
+( init )
+
+|0100 ( -> )
+
+	;hello-word 
+	&while
+		( send ) LDAk .Console/write DEO
+		INC2 LDAk ,&while JCN
+	POP2
+
+BRK
+
+@hello-word "Hello 20 "Uxn!
diff --git a/apps/plugins/varvara/devices/apu.c b/apps/plugins/varvara/devices/apu.c
new file mode 100644
index 0000000000..9c55f068fb
--- /dev/null
+++ b/apps/plugins/varvara/devices/apu.c
@@ -0,0 +1,97 @@
+#include "../uxn.h"
+#include "apu.h"
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+Copyright (c) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+#define NOTE_PERIOD (SAMPLE_FREQUENCY * 0x4000 / 11025)
+#define ADSR_STEP (SAMPLE_FREQUENCY / 0xf)
+
+/* clang-format off */
+
+static Uint32 advances[12] = {
+	0x80000, 0x879c8, 0x8facd, 0x9837f, 0xa1451, 0xaadc1,
+	0xb504f, 0xbfc88, 0xcb2ff, 0xd7450, 0xe411f, 0xf1a1c
+};
+
+/* clang-format on */
+
+static Sint32
+envelope(Apu *c, Uint32 age)
+{
+	if(!c->r) return 0x0888;
+	if(age < c->a) return 0x0888 * age / c->a;
+	if(age < c->d) return 0x0444 * (2 * c->d - c->a - age) / (c->d - c->a);
+	if(age < c->s) return 0x0444;
+	if(age < c->r) return 0x0444 * (c->r - age) / (c->r - c->s);
+	c->advance = 0;
+	return 0x0000;
+}
+
+int
+apu_render(Apu *c, Sint16 *sample, Sint16 *end)
+{
+	Sint32 s;
+	if(!c->advance || !c->period) return 0;
+	while(sample < end) {
+		c->count += c->advance;
+		c->i += c->count / c->period;
+		c->count %= c->period;
+		if(c->i >= c->len) {
+			if(!c->repeat) {
+				c->advance = 0;
+				break;
+			}
+			c->i %= c->len;
+		}
+		s = (Sint8)(c->addr[c->i] + 0x80) * envelope(c, c->age++);
+		*sample++ += s * c->volume[0] / 0x180;
+		*sample++ += s * c->volume[1] / 0x180;
+	}
+	if(!c->advance) apu_finished_handler(c);
+	return 1;
+}
+
+void
+apu_start(Apu *c, Uint16 adsr, Uint8 pitch)
+{
+	if(pitch < 108 && c->len)
+		c->advance = advances[pitch % 12] >> (8 - pitch / 12);
+	else {
+		c->advance = 0;
+		return;
+	}
+	c->a = ADSR_STEP * (adsr >> 12);
+	c->d = ADSR_STEP * (adsr >> 8 & 0xf) + c->a;
+	c->s = ADSR_STEP * (adsr >> 4 & 0xf) + c->d;
+	c->r = ADSR_STEP * (adsr >> 0 & 0xf) + c->s;
+	c->age = 0;
+	c->i = 0;
+	if(c->len <= 0x100) /* single cycle mode */
+		c->period = NOTE_PERIOD * 337 / 2 / c->len;
+	else /* sample repeat mode */
+		c->period = NOTE_PERIOD;
+}
+
+Uint8
+apu_get_vu(Apu *c)
+{
+	int i;
+	Sint32 sum[2] = {0, 0};
+	if(!c->advance || !c->period) return 0;
+	for(i = 0; i < 2; ++i) {
+		if(!c->volume[i]) continue;
+		sum[i] = 1 + envelope(c, c->age) * c->volume[i] / 0x800;
+		if(sum[i] > 0xf) sum[i] = 0xf;
+	}
+	return (sum[0] << 4) | sum[1];
+}
diff --git a/apps/plugins/varvara/devices/apu.h b/apps/plugins/varvara/devices/apu.h
new file mode 100644
index 0000000000..6531c9af55
--- /dev/null
+++ b/apps/plugins/varvara/devices/apu.h
@@ -0,0 +1,29 @@
+/*
+Copyright (c) 2021 Devine Lu Linvega
+Copyright (c) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+typedef unsigned int Uint32;
+typedef signed int Sint32;
+
+#define SAMPLE_FREQUENCY 44100
+
+typedef struct {
+	Uint8 *addr;
+	Uint32 count, advance, period, age, a, d, s, r;
+	Uint16 i, len;
+	Sint8 volume[2];
+	Uint8 pitch, repeat;
+} Apu;
+
+int apu_render(Apu *c, Sint16 *sample, Sint16 *end);
+void apu_start(Apu *c, Uint16 adsr, Uint8 pitch);
+Uint8 apu_get_vu(Apu *c);
+void apu_finished_handler(Apu *c);
diff --git a/apps/plugins/varvara/devices/ppu.c b/apps/plugins/varvara/devices/ppu.c
new file mode 100644
index 0000000000..24a1a5525b
--- /dev/null
+++ b/apps/plugins/varvara/devices/ppu.c
@@ -0,0 +1,103 @@
+#include "ppu.h"
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+Copyright (c) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+static Uint8 blending[5][16] = {
+	{0, 0, 0, 0, 1, 0, 1, 1, 2, 2, 0, 2, 3, 3, 3, 0},
+	{0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3},
+	{1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1},
+	{2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2},
+	{1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0}};
+
+static void
+ppu_clear(Ppu *p)
+{
+	Uint32 row, bound = p->height * p->width / 2;
+	for(row = 0; row < bound; ++row)
+		p->pixels[row] = 0;
+}
+
+Uint8
+ppu_set_size(Ppu *p, Uint16 width, Uint16 height)
+{
+	ppu_clear(p);
+	p->width = width;
+	p->height = height;
+	p->pixels = realloc(p->pixels, p->width * p->height * sizeof(Uint8) / 2);
+	ppu_clear(p);
+	return !!p->pixels;
+}
+
+Uint8
+ppu_read(Ppu *p, Uint16 x, Uint16 y)
+{
+	if(x < p->width && y < p->height) {
+		Uint32 row = (x + y * p->width) / 0x2;
+		Uint8 shift = !(x & 0x1) << 2;
+		Uint8 pix = p->pixels[row] >> shift;
+		if(pix & 0x0c)
+			pix = pix >> 2;
+		return pix & 0x3;
+	}
+	return 0x0;
+}
+
+void
+ppu_write(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 color)
+{
+	if(x < p->width && y < p->height) {
+		Uint32 row = (x + y * p->width) / 0x2;
+		Uint8 shift = (!(x & 0x1) << 2) + (layer << 1);
+		Uint8 pix = p->pixels[row];
+		Uint8 mask = ~(0x3 << shift);
+		Uint8 pixnew = (pix & mask) + (color << shift);
+		if(x < p->width && y < p->height)
+			p->pixels[row] = pixnew;
+		if(pix != pixnew)
+			p->reqdraw = 1;
+	}
+}
+
+void
+ppu_1bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
+{
+	Uint16 v, h;
+	for(v = 0; v < 8; v++)
+		for(h = 0; h < 8; h++) {
+			Uint8 ch1 = (sprite[v] >> (7 - h)) & 0x1;
+			if(ch1 || blending[4][color])
+				ppu_write(p,
+					layer,
+					x + (flipx ? 7 - h : h),
+					y + (flipy ? 7 - v : v),
+					blending[ch1][color]);
+		}
+}
+
+void
+ppu_2bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
+{
+	Uint16 v, h;
+	for(v = 0; v < 8; v++)
+		for(h = 0; h < 8; h++) {
+			Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1);
+			Uint8 ch2 = ((sprite[v + 8] >> (7 - h)) & 0x1);
+			Uint8 ch = ch1 + ch2 * 2;
+			if(ch || blending[4][color])
+				ppu_write(p,
+					layer,
+					x + (flipx ? 7 - h : h),
+					y + (flipy ? 7 - v : v),
+					blending[ch][color]);
+		}
+}
diff --git a/apps/plugins/varvara/devices/ppu.h b/apps/plugins/varvara/devices/ppu.h
new file mode 100644
index 0000000000..1ae47c8c9e
--- /dev/null
+++ b/apps/plugins/varvara/devices/ppu.h
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+Copyright (c) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+typedef unsigned char Uint8;
+typedef unsigned short Uint16;
+typedef unsigned int Uint32;
+
+typedef struct Ppu {
+	Uint8 *pixels, reqdraw;
+	Uint16 width, height;
+} Ppu;
+
+Uint8 ppu_set_size(Ppu *p, Uint16 width, Uint16 height);
+Uint8 ppu_read(Ppu *p, Uint16 x, Uint16 y);
+void ppu_write(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 color);
+void ppu_frame(Ppu *p);
+void ppu_1bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy);
+void ppu_2bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy);
diff --git a/apps/plugins/varvara/uxn-fast.c b/apps/plugins/varvara/uxn-fast.c
new file mode 100644
index 0000000000..c155f005b3
--- /dev/null
+++ b/apps/plugins/varvara/uxn-fast.c
@@ -0,0 +1,4048 @@
+#include "uxn.h"
+
+/*
+Copyright (u) 2021 Devine Lu Linvega
+Copyright (u) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+/*
+ ^
+/!\ THIS FILE IS AUTOMATICALLY GENERATED
+---
+
+Its contents can get overwritten with the processed contents of src/uxn.c.
+See etc/mkuxn-fast.moon for instructions.
+
+*/
+
+#define MODE_RETURN 0x40
+#define MODE_KEEP 0x80
+
+#pragma mark - Operations
+
+/* clang-format off */
+static void   poke8(Uint8 *m, Uint16 a, Uint8 b) { m[a] = b; }
+static Uint8  peek8(Uint8 *m, Uint16 a) { return m[a]; }
+static int    devw8(Device *d, Uint8 a, Uint8 b) { d->dat[a & 0xf] = b; return d->talk(d, a & 0x0f, 1); }
+static Uint8  devr8(Device *d, Uint8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf];  }
+void   poke16(Uint8 *m, Uint16 a, Uint16 b) { poke8(m, a, b >> 8); poke8(m, a + 1, b); }
+Uint16 peek16(Uint8 *m, Uint16 a) { return (peek8(m, a) << 8) + peek8(m, a + 1); }
+static int    devw16(Device *d, Uint8 a, Uint16 b) { return devw8(d, a, b >> 8) && devw8(d, a + 1, b); }
+
+/* clang-format on */
+
+#pragma mark - Core
+
+int
+uxn_eval(Uxn *u, Uint16 vec)
+{
+	Uint8 instr;
+	if(!vec || u->dev[0].dat[0xf]) 
+		return 0;
+	u->ram.ptr = vec;
+	if(u->wst.ptr > 0xf8) u->wst.ptr = 0xf8;
+	while((instr = u->ram.dat[u->ram.ptr++])) {
+		switch(instr) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-value"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+		case 0x00: /* LIT */
+		case 0x80: /* LITk */
+			{
+				u->wst.dat[u->wst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x01: /* INC */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 1] = a + 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x02: /* POP */
+			{
+				u->wst.dat[u->wst.ptr - 1];
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x03: /* DUP */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = 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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x04: /* NIP */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x05: /* SWP */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = a;
+				u->wst.dat[u->wst.ptr - 1] = b;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x06: /* OVR */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x07: /* ROT */
+			{
+				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];
+				u->wst.dat[u->wst.ptr - 3] = b;
+				u->wst.dat[u->wst.ptr - 2] = a;
+				u->wst.dat[u->wst.ptr - 1] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x08: /* EQU */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b == a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x09: /* NEQ */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b != a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x0a: /* GTH */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b > a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x0b: /* LTH */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b < a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x0c: /* JMP */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x0d: /* JCN */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x0e: /* JSR */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
+				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x0f: /* STH */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x10: /* LDZ */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.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;
+				}
+#endif
+			}
+			break;
+		case 0x11: /* STZ */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint8 b = u->wst.dat[u->wst.ptr - 2];
+				poke8(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x12: /* LDR */
+			{
+				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);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x13: /* STR */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint8 b = u->wst.dat[u->wst.ptr - 2];
+				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x14: /* LDA */
+			{
+				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);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x15: /* STA */
+			{
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 b = u->wst.dat[u->wst.ptr - 3];
+				poke8(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x16: /* DEI */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.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;
+				}
+#endif
+			}
+			break;
+		case 0x17: /* DEO */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				if(!devw8(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x18: /* ADD */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b + a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x19: /* SUB */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b - a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1a: /* MUL */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b * a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1b: /* DIV */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				if(a == 0) {
+					u->wst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->wst.dat[u->wst.ptr - 2] = b / a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1c: /* AND */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b & a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1d: /* ORA */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b | a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1e: /* EOR */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b ^ a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x1f: /* SFT */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x20: /* LIT2 */
+		case 0xa0: /* LIT2k */
+			{
+				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->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x21: /* INC2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x22: /* POP2 */
+			{
+				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x23: /* DUP2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x24: /* NIP2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x25: /* SWP2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x26: /* OVR2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x27: /* ROT2 */
+			{
+				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->wst.ptr < 6, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x28: /* EQU2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x29: /* NEQ2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x2a: /* GTH2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x2b: /* LTH2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x2c: /* JMP2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x2d: /* JCN2 */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x2e: /* JSR2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x2f: /* STH2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x30: /* LDZ2 */
+			{
+				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->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: /* STZ2 */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x32: /* LDR2 */
+			{
+				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->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: /* STR2 */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x34: /* LDA2 */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x35: /* STA2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 4;
+			}
+			break;
+		case 0x36: /* DEI2 */
+			{
+				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->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: /* DEO2 */
+			{
+				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));
+				if(!devw16(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 3;
+			}
+			break;
+		case 0x38: /* ADD2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x39: /* SUB2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3a: /* MUL2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3b: /* DIV2 */
+			{
+				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->wst.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;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3c: /* AND2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3d: /* ORA2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3e: /* EOR2 */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 2;
+			}
+			break;
+		case 0x3f: /* SFT2 */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+				u->wst.ptr -= 1;
+			}
+			break;
+		case 0x40: /* LITr */
+		case 0xc0: /* LITkr */
+			{
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x41: /* INCr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x42: /* POPr */
+			{
+				u->rst.dat[u->rst.ptr - 1];
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x43: /* DUPr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x44: /* NIPr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x45: /* SWPr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x46: /* OVRr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x47: /* ROTr */
+			{
+				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->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x48: /* EQUr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x49: /* NEQr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x4a: /* GTHr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x4b: /* LTHr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x4c: /* JMPr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x4d: /* JCNr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x4e: /* JSRr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x4f: /* STHr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x50: /* LDZr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x51: /* STZr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x52: /* LDRr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x53: /* STRr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x54: /* LDAr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x55: /* STAr */
+			{
+				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->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x56: /* DEIr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x57: /* DEOr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				if(!devw8(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x58: /* ADDr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x59: /* SUBr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5a: /* MULr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5b: /* DIVr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				if(a == 0) {
+					u->rst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->rst.dat[u->rst.ptr - 2] = b / a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5c: /* ANDr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5d: /* ORAr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5e: /* EORr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x5f: /* SFTr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x60: /* LIT2r */
+		case 0xe0: /* LIT2kr */
+			{
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr++);
+				u->rst.dat[u->rst.ptr + 1] = peek8(u->ram.dat, u->ram.ptr++);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x61: /* INC2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr - 2] = (a + 1) >> 8;
+				u->rst.dat[u->rst.ptr - 1] = (a + 1) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x62: /* POP2r */
+			{
+				(u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x63: /* DUP2r */
+			{
+				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;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x64: /* NIP2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				(u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = a >> 8;
+				u->rst.dat[u->rst.ptr - 3] = a & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x65: /* SWP2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr - 4] = b;
+				u->rst.dat[u->rst.ptr - 3] = a;
+				u->rst.dat[u->rst.ptr - 2] = d;
+				u->rst.dat[u->rst.ptr - 1] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x66: /* OVR2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = d;
+				u->rst.dat[u->rst.ptr + 1] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x67: /* ROT2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4], e = u->rst.dat[u->rst.ptr - 5], f = u->rst.dat[u->rst.ptr - 6];
+				u->rst.dat[u->rst.ptr - 6] = d;
+				u->rst.dat[u->rst.ptr - 5] = c;
+				u->rst.dat[u->rst.ptr - 4] = b;
+				u->rst.dat[u->rst.ptr - 3] = a;
+				u->rst.dat[u->rst.ptr - 2] = f;
+				u->rst.dat[u->rst.ptr - 1] = e;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 6, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x68: /* EQU2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = b == a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x69: /* NEQ2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = b != a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x6a: /* GTH2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = b > a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x6b: /* LTH2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = b < a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x6c: /* JMP2r */
+			{
+				u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x6d: /* JCN2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x6e: /* JSR2r */
+			{
+				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
+				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x6f: /* STH2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.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 < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x70: /* LDZ2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, a);
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a + 1);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x71: /* STZ2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				poke16(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x72: /* LDR2r */
+			{
+				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);
+				u->rst.dat[u->rst.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;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x73: /* STR2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x74: /* LDA2r */
+			{
+				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);
+				u->rst.dat[u->rst.ptr - 1] = peek8(u->ram.dat, a + 1);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x75: /* STA2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				Uint16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				poke16(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 4;
+			}
+			break;
+		case 0x76: /* DEI2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr - 1] = devr8(&u->dev[a >> 4], a);
+				u->rst.dat[u->rst.ptr] = devr8(&u->dev[a >> 4], a + 1);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x77: /* DEO2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				if(!devw16(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 3;
+			}
+			break;
+		case 0x78: /* ADD2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = (b + a) >> 8;
+				u->rst.dat[u->rst.ptr - 3] = (b + a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x79: /* SUB2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = (b - a) >> 8;
+				u->rst.dat[u->rst.ptr - 3] = (b - a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7a: /* MUL2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr - 4] = (b * a) >> 8;
+				u->rst.dat[u->rst.ptr - 3] = (b * a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7b: /* DIV2r */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				if(a == 0) {
+					u->rst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->rst.dat[u->rst.ptr - 4] = (b / a) >> 8;
+				u->rst.dat[u->rst.ptr - 3] = (b / a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7c: /* AND2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr - 4] = d & b;
+				u->rst.dat[u->rst.ptr - 3] = c & a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7d: /* ORA2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr - 4] = d | b;
+				u->rst.dat[u->rst.ptr - 3] = c | a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7e: /* EOR2r */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr - 4] = d ^ b;
+				u->rst.dat[u->rst.ptr - 3] = c ^ a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 2;
+			}
+			break;
+		case 0x7f: /* SFT2r */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				u->rst.dat[u->rst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
+				u->rst.dat[u->rst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+				u->rst.ptr -= 1;
+			}
+			break;
+		case 0x81: /* INCk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a + 1;
+#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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x82: /* POPk */
+			{
+				u->wst.dat[u->wst.ptr - 1];
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x83: /* DUPk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a;
+				u->wst.dat[u->wst.ptr + 1] = 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 > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x84: /* NIPk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x85: /* SWPk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = a;
+				u->wst.dat[u->wst.ptr + 1] = b;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0x86: /* OVRk */
+			{
+				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;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 252, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 3;
+			}
+			break;
+		case 0x87: /* ROTk */
+			{
+				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];
+				u->wst.dat[u->wst.ptr] = b;
+				u->wst.dat[u->wst.ptr + 1] = a;
+				u->wst.dat[u->wst.ptr + 2] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 252, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 3;
+			}
+			break;
+		case 0x88: /* EQUk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b == a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x89: /* NEQk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b != a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x8a: /* GTHk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b > a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x8b: /* LTHk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b < a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x8c: /* JMPk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x8d: /* JCNk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x8e: /* JSRk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
+				u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
+				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->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0x8f: /* STHk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0x90: /* LDZk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = 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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x91: /* STZk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint8 b = u->wst.dat[u->wst.ptr - 2];
+				poke8(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x92: /* LDRk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.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;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 254, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x93: /* STRk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				Uint8 b = u->wst.dat[u->wst.ptr - 2];
+				poke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x94: /* LDAk */
+			{
+				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);
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x95: /* STAk */
+			{
+				Uint16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+				Uint8 b = u->wst.dat[u->wst.ptr - 3];
+				poke8(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x96: /* DEIk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = 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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x97: /* DEOk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				if(!devw8(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0x98: /* ADDk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b + a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x99: /* SUBk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b - a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9a: /* MULk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b * a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9b: /* DIVk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				if(a == 0) {
+					u->wst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->wst.dat[u->wst.ptr] = b / a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9c: /* ANDk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b & a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9d: /* ORAk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b | a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9e: /* EORk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b ^ a;
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0x9f: /* SFTk */
+			{
+				Uint8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
+				u->wst.dat[u->wst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4);
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 1;
+			}
+			break;
+		case 0xa1: /* INC2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xa2: /* POP2k */
+			{
+				(u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xa3: /* DUP2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 251, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 4;
+			}
+			break;
+		case 0xa4: /* NIP2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xa5: /* SWP2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 251, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 4;
+			}
+			break;
+		case 0xa6: /* OVR2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 249, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 6;
+			}
+			break;
+		case 0xa7: /* ROT2k */
+			{
+				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->wst.ptr < 6, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 249, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 6;
+			}
+			break;
+		case 0xa8: /* EQU2k */
+			{
+				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->wst.ptr < 4, 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 0xa9: /* NEQ2k */
+			{
+				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->wst.ptr < 4, 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 0xaa: /* GTH2k */
+			{
+				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->wst.ptr < 4, 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 0xab: /* LTH2k */
+			{
+				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->wst.ptr < 4, 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 0xac: /* JMP2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xad: /* JCN2k */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xae: /* JSR2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xaf: /* STH2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xb0: /* LDZ2k */
+			{
+				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->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xb1: /* STZ2k */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xb2: /* LDR2k */
+			{
+				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->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xb3: /* STR2k */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xb4: /* LDA2k */
+			{
+				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->wst.ptr < 2, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xb5: /* STA2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xb6: /* DEI2k */
+			{
+				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->wst.ptr < 1, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xb7: /* DEO2k */
+			{
+				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));
+				if(!devw16(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xb8: /* ADD2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xb9: /* SUB2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xba: /* MUL2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xbb: /* DIV2k */
+			{
+				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->wst.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;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xbc: /* AND2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xbd: /* ORA2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xbe: /* EOR2k */
+			{
+				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->wst.ptr < 4, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xbf: /* SFT2k */
+			{
+				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->wst.ptr < 3, 0)) {
+					u->wst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xc1: /* INCkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xc2: /* POPkr */
+			{
+				u->rst.dat[u->rst.ptr - 1];
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xc3: /* DUPkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xc4: /* NIPkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xc5: /* SWPkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xc6: /* OVRkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 252, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 3;
+			}
+			break;
+		case 0xc7: /* ROTkr */
+			{
+				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->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 252, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 3;
+			}
+			break;
+		case 0xc8: /* EQUkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xc9: /* NEQkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xca: /* GTHkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xcb: /* LTHkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xcc: /* JMPkr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->ram.ptr += (Sint8)a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xcd: /* JCNkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xce: /* JSRkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xcf: /* STHkr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->wst.dat[u->wst.ptr] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 1, 0)) {
+					u->rst.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 0xd0: /* LDZkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xd1: /* STZkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xd2: /* LDRkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xd3: /* STRkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xd4: /* LDAkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xd5: /* STAkr */
+			{
+				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->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xd6: /* DEIkr */
+			{
+				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->rst.ptr < 1, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xd7: /* DEOkr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				if(!devw8(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xd8: /* ADDkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xd9: /* SUBkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xda: /* MULkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xdb: /* DIVkr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
+				if(a == 0) {
+					u->rst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->rst.dat[u->rst.ptr] = b / a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xdc: /* ANDkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xdd: /* ORAkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xde: /* EORkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xdf: /* SFTkr */
+			{
+				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->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xe1: /* INC2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				u->rst.dat[u->rst.ptr] = (a + 1) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (a + 1) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xe2: /* POP2kr */
+			{
+				(u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xe3: /* DUP2kr */
+			{
+				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;
+				u->rst.dat[u->rst.ptr + 3] = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 251, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 4;
+			}
+			break;
+		case 0xe4: /* NIP2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				(u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = a >> 8;
+				u->rst.dat[u->rst.ptr + 1] = a & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xe5: /* SWP2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = b;
+				u->rst.dat[u->rst.ptr + 1] = a;
+				u->rst.dat[u->rst.ptr + 2] = d;
+				u->rst.dat[u->rst.ptr + 3] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 251, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 4;
+			}
+			break;
+		case 0xe6: /* OVR2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = d;
+				u->rst.dat[u->rst.ptr + 1] = c;
+				u->rst.dat[u->rst.ptr + 2] = b;
+				u->rst.dat[u->rst.ptr + 3] = a;
+				u->rst.dat[u->rst.ptr + 4] = d;
+				u->rst.dat[u->rst.ptr + 5] = c;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 249, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 6;
+			}
+			break;
+		case 0xe7: /* ROT2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4], e = u->rst.dat[u->rst.ptr - 5], f = u->rst.dat[u->rst.ptr - 6];
+				u->rst.dat[u->rst.ptr] = d;
+				u->rst.dat[u->rst.ptr + 1] = c;
+				u->rst.dat[u->rst.ptr + 2] = b;
+				u->rst.dat[u->rst.ptr + 3] = a;
+				u->rst.dat[u->rst.ptr + 4] = f;
+				u->rst.dat[u->rst.ptr + 5] = e;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 6, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 249, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 6;
+			}
+			break;
+		case 0xe8: /* EQU2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = b == a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xe9: /* NEQ2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = b != a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xea: /* GTH2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = b > a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xeb: /* LTH2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = b < a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 254, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 1;
+			}
+			break;
+		case 0xec: /* JMP2kr */
+			{
+				u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xed: /* JCN2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xee: /* JSR2kr */
+			{
+				u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
+				u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
+				u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xef: /* STH2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.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 < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->wst.ptr > 253, 0)) {
+					u->wst.error = 2;
+					goto error;
+				}
+#endif
+				u->wst.ptr += 2;
+			}
+			break;
+		case 0xf0: /* LDZ2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, a);
+				u->rst.dat[u->rst.ptr + 1] = peek8(u->ram.dat, a + 1);
+#ifndef NO_STACK_CHECKS
+				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;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xf1: /* STZ2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				poke16(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xf2: /* LDR2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = peek8(u->ram.dat, u->ram.ptr + (Sint8)a);
+				u->rst.dat[u->rst.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;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xf3: /* STR2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				poke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xf4: /* LDA2kr */
+			{
+				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);
+				u->rst.dat[u->rst.ptr + 1] = peek8(u->ram.dat, a + 1);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 2, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xf5: /* STA2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
+				Uint16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				poke16(u->ram.dat, a, b);
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xf6: /* DEI2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				u->rst.dat[u->rst.ptr] = devr8(&u->dev[a >> 4], a);
+				u->rst.dat[u->rst.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;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xf7: /* DEO2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				if(!devw16(&u->dev[a >> 4], a, b))
+					return 1;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+#endif
+			}
+			break;
+		case 0xf8: /* ADD2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = (b + a) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (b + a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xf9: /* SUB2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = (b - a) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (b - a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xfa: /* MUL2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				u->rst.dat[u->rst.ptr] = (b * a) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (b * a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xfb: /* DIV2kr */
+			{
+				Uint16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
+				if(a == 0) {
+					u->rst.error = 3;
+#ifndef NO_STACK_CHECKS
+					goto error;
+#endif
+					a = 1;
+				}
+				u->rst.dat[u->rst.ptr] = (b / a) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (b / a) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xfc: /* AND2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = d & b;
+				u->rst.dat[u->rst.ptr + 1] = c & a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xfd: /* ORA2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = d | b;
+				u->rst.dat[u->rst.ptr + 1] = c | a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xfe: /* EOR2kr */
+			{
+				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], d = u->rst.dat[u->rst.ptr - 4];
+				u->rst.dat[u->rst.ptr] = d ^ b;
+				u->rst.dat[u->rst.ptr + 1] = c ^ a;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 4, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+		case 0xff: /* SFT2kr */
+			{
+				Uint8 a = u->rst.dat[u->rst.ptr - 1];
+				Uint16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
+				u->rst.dat[u->rst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
+				u->rst.dat[u->rst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
+#ifndef NO_STACK_CHECKS
+				if(__builtin_expect(u->rst.ptr < 3, 0)) {
+					u->rst.error = 1;
+					goto error;
+				}
+				if(__builtin_expect(u->rst.ptr > 253, 0)) {
+					u->rst.error = 2;
+					goto error;
+				}
+#endif
+				u->rst.ptr += 2;
+			}
+			break;
+#pragma GCC diagnostic pop
+		}
+	}
+	return 1;
+#ifndef NO_STACK_CHECKS
+error:
+	if(u->wst.error)
+		return uxn_halt(u, u->wst.error, "Working-stack", instr);
+	else
+		return uxn_halt(u, u->rst.error, "Return-stack", instr);
+#endif
+}
+
+int
+uxn_boot(Uxn *u)
+{
+	unsigned int i;
+	char *cptr = (char *)u;
+	for(i = 0; i < sizeof(*u); i++)
+		cptr[i] = 0x00;
+	return 1;
+}
+
+Device *
+uxn_port(Uxn *u, Uint8 id, int (*talkfn)(Device *d, Uint8 b0, Uint8 w))
+{
+	Device *d = &u->dev[id];
+	d->addr = id * 0x10;
+	d->u = u;
+	d->mem = u->ram.dat;
+	d->talk = talkfn;
+	return d;
+}
diff --git a/apps/plugins/varvara/uxn.c b/apps/plugins/varvara/uxn.c
new file mode 100644
index 0000000000..76a1725bf3
--- /dev/null
+++ b/apps/plugins/varvara/uxn.c
@@ -0,0 +1,157 @@
+#include "uxn.h"
+#include <stdio.h>
+/*
+Copyright (u) 2021 Devine Lu Linvega
+Copyright (u) 2021 Andrew Alderwick
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+#define MODE_SHORT 0x20
+#define MODE_RETURN 0x40
+#define MODE_KEEP 0x80
+
+#pragma mark - Operations
+
+/* clang-format off */
+
+/* Utilities */
+static void   (*push)(Stack *s, Uint16 a);
+static Uint16 (*pop8)(Stack *s);
+static Uint16 (*pop)(Stack *s);
+static void   (*poke)(Uint8 *m, Uint16 a, Uint16 b);
+static Uint16 (*peek)(Uint8 *m, Uint16 a);
+static int    (*devw)(Device *d, Uint8 a, Uint16 b);
+static Uint16 (*devr)(Device *d, Uint8 a);
+static void   (*warp)(Uxn *u, Uint16 a);
+static void   (*pull)(Uxn *u);
+/* byte mode */
+static void   push8(Stack *s, Uint16 a) { if(s->ptr == 0xff) { s->error = 2; return; } s->dat[s->ptr++] = a; }
+static Uint16 pop8k(Stack *s) { if(s->kptr == 0) { s->error = 1; return 0; } return s->dat[--s->kptr]; }
+static Uint16 pop8d(Stack *s) { if(s->ptr == 0) { s->error = 1; return 0; } return s->dat[--s->ptr]; }
+static void   poke8(Uint8 *m, Uint16 a, Uint16 b) { m[a] = b; }
+static Uint16 peek8(Uint8 *m, Uint16 a) { return m[a]; }
+static int    devw8(Device *d, Uint8 a, Uint16 b) { d->dat[a & 0xf] = b; return d->talk(d, a & 0x0f, 1); }
+static Uint16 devr8(Device *d, Uint8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf];  }
+static void   warp8(Uxn *u, Uint16 a){ u->ram.ptr += (Sint8)a; }
+static void   pull8(Uxn *u){ push8(u->src, peek8(u->ram.dat, u->ram.ptr++)); }
+/* short mode */
+static void   push16(Stack *s, Uint16 a) { push8(s, a >> 8); push8(s, a); }
+static Uint16 pop16(Stack *s) { Uint8 a = pop8(s), b = pop8(s); return a + (b << 8); }
+	   void   poke16(Uint8 *m, Uint16 a, Uint16 b) { poke8(m, a, b >> 8); poke8(m, a + 1, b); }
+	   Uint16 peek16(Uint8 *m, Uint16 a) { return (peek8(m, a) << 8) + peek8(m, a + 1); }
+static int    devw16(Device *d, Uint8 a, Uint16 b) { return devw8(d, a, b >> 8) && devw8(d, a + 1, b); }
+static Uint16 devr16(Device *d, Uint8 a) { return (devr8(d, a) << 8) + devr8(d, a + 1); }
+static void   warp16(Uxn *u, Uint16 a){ u->ram.ptr = a; }
+static void   pull16(Uxn *u){ push16(u->src, peek16(u->ram.dat, u->ram.ptr++)); u->ram.ptr++; }
+
+#pragma mark - Core
+
+int
+uxn_eval(Uxn *u, Uint16 vec)
+{
+	Uint8 instr;
+	Uint16 a,b,c;
+	if(!vec || u->dev[0].dat[0xf])
+		return 0;
+	u->ram.ptr = vec;
+	if(u->wst.ptr > 0xf8) u->wst.ptr = 0xf8;
+	while((instr = u->ram.dat[u->ram.ptr++])) {
+		/* Return Mode */
+		if(instr & MODE_RETURN) {
+			u->src = &u->rst; 
+			u->dst = &u->wst;
+		} else {
+			u->src = &u->wst; 
+			u->dst = &u->rst;
+		}
+		/* Keep Mode */
+		if(instr & MODE_KEEP) {
+			pop8 = pop8k;
+			u->src->kptr = u->src->ptr;
+		} else {
+			pop8 = pop8d;
+		}
+		/* Short Mode */
+		if(instr & MODE_SHORT) {
+			push = push16; pop = pop16;
+			poke = poke16; peek = peek16;
+			devw = devw16; devr = devr16;
+			warp = warp16; pull = pull16;
+		} else {
+			push = push8; pop = pop8;
+			poke = poke8; peek = peek8;
+			devw = devw8; devr = devr8;
+			warp = warp8; pull = pull8;
+		}
+		switch(instr & 0x1f){
+			/* Stack */
+			case 0x00: /* LIT */ pull(u); break;
+			case 0x01: /* INC */ a = pop(u->src); push(u->src, a + 1); break;
+			case 0x02: /* POP */ pop(u->src); break;
+			case 0x03: /* DUP */ a = pop(u->src); push(u->src, a); push(u->src, a); break;
+			case 0x04: /* NIP */ a = pop(u->src); pop(u->src); push(u->src, a); break;
+			case 0x05: /* SWP */ a = pop(u->src), b = pop(u->src); push(u->src, a); push(u->src, b); break;
+			case 0x06: /* OVR */ a = pop(u->src), b = pop(u->src); push(u->src, b); push(u->src, a); push(u->src, b); break;
+			case 0x07: /* ROT */ a = pop(u->src), b = pop(u->src), c = pop(u->src); push(u->src, b); push(u->src, a); push(u->src, c); break;
+			/* Logic */
+			case 0x08: /* EQU */ a = pop(u->src), b = pop(u->src); push8(u->src, b == a); break;
+			case 0x09: /* NEQ */ a = pop(u->src), b = pop(u->src); push8(u->src, b != a); break;
+			case 0x0a: /* GTH */ a = pop(u->src), b = pop(u->src); push8(u->src, b > a); break;
+			case 0x0b: /* LTH */ a = pop(u->src), b = pop(u->src); push8(u->src, b < a); break;
+			case 0x0c: /* JMP */ a = pop(u->src); warp(u, a); break;
+			case 0x0d: /* JCN */ a = pop(u->src); if(pop8(u->src)) warp(u, a); break;
+			case 0x0e: /* JSR */ a = pop(u->src); push16(u->dst, u->ram.ptr); warp(u, a); break;
+			case 0x0f: /* STH */ a = pop(u->src); push(u->dst, a); break;
+			/* Memory */
+			case 0x10: /* LDZ */ a = pop8(u->src); push(u->src, peek(u->ram.dat, a)); break;
+			case 0x11: /* STZ */ a = pop8(u->src); b = pop(u->src); poke(u->ram.dat, a, b); break;
+			case 0x12: /* LDR */ a = pop8(u->src); push(u->src, peek(u->ram.dat, u->ram.ptr + (Sint8)a)); break;
+			case 0x13: /* STR */ a = pop8(u->src); b = pop(u->src); poke(u->ram.dat, u->ram.ptr + (Sint8)a, b); break;
+			case 0x14: /* LDA */ a = pop16(u->src); push(u->src, peek(u->ram.dat, a)); break;
+			case 0x15: /* STA */ a = pop16(u->src); b = pop(u->src); poke(u->ram.dat, a, b); break;
+			case 0x16: /* DEI */ a = pop8(u->src); push(u->src, devr(&u->dev[a >> 4], a)); break;
+			case 0x17: /* DEO */ a = pop8(u->src); b = pop(u->src); if (!devw(&u->dev[a >> 4], a, b)) return 1; break;
+			/* Arithmetic */
+			case 0x18: /* ADD */ a = pop(u->src), b = pop(u->src); push(u->src, b + a); break;
+			case 0x19: /* SUB */ a = pop(u->src), b = pop(u->src); push(u->src, b - a); break;
+			case 0x1a: /* MUL */ a = pop(u->src), b = pop(u->src); push(u->src, b * a); break;
+			case 0x1b: /* DIV */ a = pop(u->src), b = pop(u->src); if(a == 0) { u->src->error = 3; a = 1; } push(u->src, b / a); break;
+			case 0x1c: /* AND */ a = pop(u->src), b = pop(u->src); push(u->src, b & a); break;
+			case 0x1d: /* ORA */ a = pop(u->src), b = pop(u->src); push(u->src, b | a); break;
+			case 0x1e: /* EOR */ a = pop(u->src), b = pop(u->src); push(u->src, b ^ a); break;
+			case 0x1f: /* SFT */ a = pop8(u->src), b = pop(u->src); push(u->src, b >> (a & 0x0f) << ((a & 0xf0) >> 4)); break;
+		}
+		if(u->wst.error) return uxn_halt(u, u->wst.error, "Working-stack", instr);
+		if(u->rst.error) return uxn_halt(u, u->rst.error, "Return-stack", instr);
+	}
+	return 1;
+}
+
+/* clang-format on */
+
+int
+uxn_boot(Uxn *u)
+{
+	unsigned int i;
+	char *cptr = (char *)u;
+	for(i = 0; i < sizeof(*u); i++)
+		cptr[i] = 0x00;
+	return 1;
+}
+
+Device *
+uxn_port(Uxn *u, Uint8 id, int (*talkfn)(Device *d, Uint8 b0, Uint8 w))
+{
+	Device *d = &u->dev[id];
+	d->addr = id * 0x10;
+	d->u = u;
+	d->mem = u->ram.dat;
+	d->talk = talkfn;
+	return d;
+}
diff --git a/apps/plugins/varvara/uxn.h b/apps/plugins/varvara/uxn.h
new file mode 100644
index 0000000000..548efdc416
--- /dev/null
+++ b/apps/plugins/varvara/uxn.h
@@ -0,0 +1,50 @@
+/*
+Copyright (c) 2021 Devine Lu Linvega
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+typedef unsigned char Uint8;
+typedef signed char Sint8;
+typedef unsigned short Uint16;
+typedef signed short Sint16;
+
+#define PAGE_PROGRAM 0x0100
+
+typedef struct {
+	Uint8 ptr, kptr, error;
+	Uint8 dat[256];
+} Stack;
+
+typedef struct {
+	Uint16 ptr;
+	Uint8 dat[65536];
+} Memory;
+
+typedef struct Device {
+	struct Uxn *u;
+	Uint8 addr, dat[16], *mem;
+	Uint16 vector;
+	int (*talk)(struct Device *d, Uint8, Uint8);
+} Device;
+
+typedef struct Uxn {
+	Stack wst, rst, *src, *dst;
+	Memory ram;
+	Device dev[16];
+} Uxn;
+
+struct Uxn;
+
+void poke16(Uint8 *m, Uint16 a, Uint16 b);
+Uint16 peek16(Uint8 *m, Uint16 a);
+
+int uxn_boot(Uxn *c);
+int uxn_eval(Uxn *u, Uint16 vec);
+int uxn_halt(Uxn *u, Uint8 error, char *name, int id);
+Device *uxn_port(Uxn *u, Uint8 id, int (*talkfn)(Device *, Uint8, Uint8));
diff --git a/apps/plugins/varvara/uxnasm.c b/apps/plugins/varvara/uxnasm.c
new file mode 100644
index 0000000000..26dce462c4
--- /dev/null
+++ b/apps/plugins/varvara/uxnasm.c
@@ -0,0 +1,426 @@
+#include <stdio.h>
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+#define TRIM 0x0100
+#define LENGTH 0x10000
+
+#define LABELS 512
+#define MACROS 256
+
+typedef unsigned char Uint8;
+typedef signed char Sint8;
+typedef unsigned short Uint16;
+
+typedef struct {
+	char name[64], items[64][64];
+	Uint8 len;
+} Macro;
+
+typedef struct {
+	char name[64];
+	Uint16 addr, refs;
+} Label;
+
+typedef struct {
+	Uint8 data[LENGTH];
+	Uint16 ptr, length, llen, mlen;
+	Label labels[LABELS];
+	Macro macros[MACROS];
+} Program;
+
+Program p;
+static Uint16 addr = 0;
+
+/* clang-format off */
+
+static char ops[][4] = {
+	"LIT", "INC", "POP", "DUP", "NIP", "SWP", "OVR", "ROT",
+	"EQU", "NEQ", "GTH", "LTH", "JMP", "JCN", "JSR", "STH",
+	"LDZ", "STZ", "LDR", "STR", "LDA", "STA", "DEI", "DEO",
+	"ADD", "SUB", "MUL", "DIV", "AND", "ORA", "EOR", "SFT"
+};
+
+static int   cpos(char *s, char a){ int i = 0; char c; while((c = s[i++])) if(c == a) return i; return -1; }
+static int   scmp(char *a, char *b, int len) { int i = 0; while(a[i] == b[i]) if(!a[i] || ++i >= len) return 1; return 0; } /* string compare */
+static int   sihx(char *s) { int i = 0; char c; while((c = s[i++])) if(!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f')) return 0; return i > 1; } /* string is hexadecimal */
+static int   shex(char *s) { int n = 0, i = 0; char c; while((c = s[i++])) if(c >= '0' && c <= '9') n = n * 16 + (c - '0'); else if(c >= 'a' && c <= 'f') n = n * 16 + 10 + (c - 'a'); return n; } /* string to num */
+static int   slen(char *s) { int i = 0; while(s[i]) ++i; return i; } /* string length */
+static char *scpy(char *src, char *dst, int len) { int i = 0; while((dst[i] = src[i]) && i < len - 2) i++; dst[i + 1] = '\0'; return dst; } /* string copy */
+static char *scat(char *dst, const char *src) { char *ptr = dst + slen(dst); while(*src) *ptr++ = *src++; *ptr = '\0'; return dst; } /* string cat */
+
+#pragma mark - Helpers
+
+/* clang-format on */
+
+#pragma mark - I/O
+
+static Macro *
+findmacro(char *name)
+{
+	int i;
+	for(i = 0; i < p.mlen; ++i)
+		if(scmp(p.macros[i].name, name, 64))
+			return &p.macros[i];
+	return NULL;
+}
+
+static Label *
+findlabel(char *name)
+{
+	int i;
+	for(i = 0; i < p.llen; ++i)
+		if(scmp(p.labels[i].name, name, 64))
+			return &p.labels[i];
+	return NULL;
+}
+
+static Uint8
+findopcode(char *s)
+{
+	int i;
+	for(i = 0; i < 0x20; ++i) {
+		int m = 0;
+		if(!scmp(ops[i], s, 3))
+			continue;
+		while(s[3 + m]) {
+			if(s[3 + m] == '2')
+				i |= (1 << 5); /* mode: short */
+			else if(s[3 + m] == 'r')
+				i |= (1 << 6); /* mode: return */
+			else if(s[3 + m] == 'k')
+				i |= (1 << 7); /* mode: keep */
+			else
+				return 0; /* failed to match */
+			m++;
+		}
+		if(!i) i |= (1 << 7); /* force LIT nonzero (keep is ignored) */
+		return i;
+	}
+	return 0;
+}
+
+static void
+pushbyte(Uint8 b, int lit)
+{
+	if(lit) pushbyte(findopcode("LIT"), 0);
+	p.data[p.ptr++] = b;
+	p.length = p.ptr;
+}
+
+static void
+pushshort(Uint16 s, int lit)
+{
+	if(lit) pushbyte(findopcode("LIT2"), 0);
+	pushbyte((s >> 8) & 0xff, 0);
+	pushbyte(s & 0xff, 0);
+}
+
+static void
+pushword(char *s)
+{
+	int i = 0;
+	char c;
+	while((c = s[i++])) pushbyte(c, 0);
+}
+
+static char *
+sublabel(char *src, char *scope, char *name)
+{
+	return scat(scat(scpy(scope, src, 64), "/"), name);
+}
+
+#pragma mark - Parser
+
+static int
+error(char *name, char *msg)
+{
+	fprintf(stderr, "%s: %s\n", name, msg);
+	return 0;
+}
+
+static int
+makemacro(char *name, FILE *f)
+{
+	Macro *m;
+	char word[64];
+	if(findmacro(name))
+		return error("Macro duplicate", name);
+	if(sihx(name) && slen(name) % 2 == 0)
+		return error("Macro name is hex number", name);
+	if(findopcode(name) || scmp(name, "BRK", 4) || !slen(name) || scmp(name, "include", 8))
+		return error("Macro name is invalid", name);
+	if(p.mlen == MACROS)
+		return error("Too many macros", name);
+	m = &p.macros[p.mlen++];
+	scpy(name, m->name, 64);
+	while(fscanf(f, "%63s", word) == 1) {
+		if(word[0] == '{') continue;
+		if(word[0] == '}') break;
+		if(m->len > 64)
+			return error("Macro too large", name);
+		scpy(word, m->items[m->len++], 64);
+	}
+	return 1;
+}
+
+static int
+makelabel(char *name)
+{
+	Label *l;
+	if(findlabel(name))
+		return error("Label duplicate", name);
+	if(sihx(name) && slen(name) % 2 == 0)
+		return error("Label name is hex number", name);
+	if(findopcode(name) || scmp(name, "BRK", 4) || !slen(name))
+		return error("Label name is invalid", name);
+	if(p.llen == LABELS)
+		return error("Too many labels", name);
+	l = &p.labels[p.llen++];
+	l->addr = addr;
+	l->refs = 0;
+	scpy(name, l->name, 64);
+	return 1;
+}
+
+static int
+addref(Label *l, Uint8 rel)
+{
+	if(rel) {
+		int pos = cpos(l->name, '/');
+		if(pos != -1) {
+			char parent[64];
+			Label *rl = findlabel(scpy(l->name, parent, pos));
+			if(rl)
+				++rl->refs;
+		}
+	}
+	return ++l->refs;
+}
+
+static int
+skipblock(char *w, int *cap, char a, char b)
+{
+	if(w[0] == b) {
+		*cap = 0;
+		return 1;
+	}
+	if(w[0] == a) *cap = 1;
+	if(*cap) return 1;
+	return 0;
+}
+
+static int
+walktoken(char *w)
+{
+	Macro *m;
+	if(findopcode(w) || scmp(w, "BRK", 4))
+		return 1;
+	switch(w[0]) {
+	case '[': return 0;
+	case ']': return 0;
+	case '\'': return 1;
+	case '.': return 2; /* zero-page: LIT addr-lb */
+	case ',': return 2; /* relative:  LIT addr-rel */
+	case ':': return 2; /* absolute:      addr-hb addr-lb */
+	case ';': return 3; /* absolute:  LIT addr-hb addr-lb */
+	case '$': return shex(w + 1);
+	case '#': return slen(w + 1) == 4 ? 3 : 2;
+	case '"': return slen(w + 1);
+	}
+	if((m = findmacro(w))) {
+		int i, res = 0;
+		for(i = 0; i < m->len; ++i)
+			res += walktoken(m->items[i]);
+		return res;
+	}
+	if(sihx(w) && slen(w) == 2)
+		return 1;
+	else if(sihx(w) && slen(w) == 4)
+		return 2;
+	return error("Invalid token", w);
+}
+
+static int
+parsetoken(char *w)
+{
+	Label *l;
+	Macro *m;
+	if(w[0] == '.' && (l = findlabel(w + 1))) { /* zero-page */
+		if(l->addr > 0xff)
+			return error("Address is not in zero page", w);
+		pushbyte(l->addr, 1);
+		return addref(l, 1);
+	} else if(w[0] == ',' && (l = findlabel(w + 1))) { /* relative */
+		int off = l->addr - p.ptr - 3;
+		if(off < -126 || off > 126)
+			return error("Address is too far", w);
+		pushbyte((Sint8)off, 1);
+		return addref(l, 0);
+	} else if(w[0] == ':' && (l = findlabel(w + 1))) { /* raw */
+		pushshort(l->addr, 0);
+		return addref(l, 1);
+	} else if(w[0] == ';' && (l = findlabel(w + 1))) { /* absolute */
+		pushshort(l->addr, 1);
+		return addref(l, 1);
+	} else if(findopcode(w) || scmp(w, "BRK", 4)) { /* opcode */
+		pushbyte(findopcode(w), 0);
+		return 1;
+	} else if(w[0] == '"') { /* string */
+		pushword(w + 1);
+		return 1;
+	} else if(w[0] == '\'') { /* char */
+		pushbyte((Uint8)w[1], 0);
+		return 1;
+	} else if(w[0] == '#') { /* immediate */
+		if(slen(w + 1) == 1)
+			pushbyte((Uint8)w[1], 1);
+		if(sihx(w + 1) && slen(w + 1) == 2)
+			pushbyte(shex(w + 1), 1);
+		else if(sihx(w + 1) && slen(w + 1) == 4)
+			pushshort(shex(w + 1), 1);
+		else
+			return error("Invalid hexadecimal literal", w);
+		return 1;
+	} else if(sihx(w)) { /* raw */
+		if(slen(w) == 2)
+			pushbyte(shex(w), 0);
+		else if(slen(w) == 4)
+			pushshort(shex(w), 0);
+		else
+			return error("Invalid hexadecimal value", w);
+		return 1;
+	} else if((m = findmacro(w))) {
+		int i;
+		for(i = 0; i < m->len; ++i)
+			if(!parsetoken(m->items[i]))
+				return error("Invalid macro", m->name);
+		return 1;
+	}
+	return error("Invalid token", w);
+}
+
+static int
+doinclude(FILE *f, int (*pass)(FILE *))
+{
+	char word[64];
+	FILE *finc;
+	int ret;
+	if(fscanf(f, "%63s", word) != 1)
+		return error("End of input", "include");
+	if(!(finc = fopen(word, "r")))
+		return error("Include failed to open", word);
+	ret = pass(finc);
+	fclose(finc);
+	return ret;
+}
+
+static int
+pass1(FILE *f)
+{
+	int ccmnt = 0;
+	char w[64], scope[64], subw[64];
+	while(fscanf(f, "%63s", w) == 1) {
+		if(skipblock(w, &ccmnt, '(', ')')) continue;
+		if(slen(w) >= 63)
+			return error("Pass 1 - Invalid token", w);
+		if(w[0] == '|') {
+			if(!sihx(w + 1))
+				return error("Pass 1 - Invalid padding", w);
+			addr = shex(w + 1);
+		} else if(w[0] == '%') {
+			if(!makemacro(w + 1, f))
+				return error("Pass 1 - Invalid macro", w);
+		} else if(w[0] == '@') {
+			if(!makelabel(w + 1))
+				return error("Pass 1 - Invalid label", w);
+			scpy(w + 1, scope, 64);
+		} else if(w[0] == '&') {
+			if(!makelabel(sublabel(subw, scope, w + 1)))
+				return error("Pass 1 - Invalid sublabel", w);
+		} else if(scmp(w, "include", 8)) {
+			if(!doinclude(f, pass1))
+				return 0;
+		} else if(sihx(w))
+			addr += slen(w) / 2;
+		else
+			addr += walktoken(w);
+	}
+	rewind(f);
+	return 1;
+}
+
+static int
+pass2(FILE *f)
+{
+	int ccmnt = 0, cmacr = 0;
+	char w[64], scope[64], subw[64];
+	while(fscanf(f, "%63s", w) == 1) {
+		if(w[0] == '%') continue;
+		if(w[0] == '&') continue;
+		if(w[0] == '[') continue;
+		if(w[0] == ']') continue;
+		if(skipblock(w, &ccmnt, '(', ')')) continue;
+		if(skipblock(w, &cmacr, '{', '}')) continue;
+		if(w[0] == '|') {
+			if(p.length && (Uint16)shex(w + 1) < p.ptr)
+				return error("Pass 2 - Memory overwrite", w);
+			p.ptr = shex(w + 1);
+			continue;
+		} else if(w[0] == '$') {
+			if(p.length && (Uint16)(p.ptr + shex(w + 1)) < p.ptr)
+				return error("Pass 2 - Memory overwrite", w);
+			p.ptr += shex(w + 1);
+			continue;
+		} else if(w[0] == '@') {
+			scpy(w + 1, scope, 64);
+			continue;
+		} else if(scmp(w, "include", 8)) {
+			if(!doinclude(f, pass2))
+				return 0;
+			continue;
+		}
+		if(w[1] == '&' && (w[0] == '.' || w[0] == ',' || w[0] == ';' || w[0] == ':'))
+			scpy(sublabel(subw, scope, w + 2), w + 1, 64);
+		if(!parsetoken(w))
+			return error("Pass 2 - Unknown label", w);
+	}
+	return 1;
+}
+
+static void
+cleanup(char *filename)
+{
+	int i;
+	for(i = 0; i < p.llen; ++i)
+		if(p.labels[i].name[0] >= 'A' && p.labels[i].name[0] <= 'Z')
+			continue; /* Ignore capitalized labels(devices) */
+		else if(!p.labels[i].refs)
+			fprintf(stderr, "--- Unused label: %s\n", p.labels[i].name);
+	fprintf(stderr, "Assembled %s in %.2fkb(%.2f%% used), %d labels, %d macros.\n", filename, (p.length - TRIM) / 1024.0, p.length / 652.80, p.llen, p.mlen);
+}
+
+int
+main(int argc, char *argv[])
+{
+	FILE *f;
+	if(argc < 3)
+		return !error("usage", "input.tal output.rom");
+	if(!(f = fopen(argv[1], "r")))
+		return !error("Load", "Failed to open source.");
+	if(!pass1(f) || !pass2(f))
+		return !error("Assembly", "Failed to assemble rom.");
+	fwrite(p.data + TRIM, p.length - TRIM, 1, fopen(argv[2], "wb"));
+	fclose(f);
+	cleanup(argv[2]);
+	return 0;
+}
diff --git a/apps/plugins/varvara/uxncli.c b/apps/plugins/varvara/uxncli.c
new file mode 100644
index 0000000000..87b75a7c9e
--- /dev/null
+++ b/apps/plugins/varvara/uxncli.c
@@ -0,0 +1,211 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <time.h>
+#include "uxn.h"
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+#pragma mark - Core
+
+static Device *devsystem, *devconsole;
+
+static int
+error(char *msg, const char *err)
+{
+	fprintf(stderr, "Error %s: %s\n", msg, err);
+	return 0;
+}
+
+static void
+inspect(Stack *s, char *name)
+{
+	Uint8 x, y;
+	fprintf(stderr, "\n%s\n", name);
+	for(y = 0; y < 0x04; ++y) {
+		for(x = 0; x < 0x08; ++x) {
+			Uint8 p = y * 0x08 + x;
+			fprintf(stderr,
+				p == s->ptr ? "[%02x]" : " %02x ",
+				s->dat[p]);
+		}
+		fprintf(stderr, "\n");
+	}
+}
+
+#pragma mark - Devices
+
+static int
+system_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(!w) { /* read */
+		switch(b0) {
+		case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
+		case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
+		}
+	} else { /* write */
+		switch(b0) {
+		case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
+		case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
+		case 0xe:
+			inspect(&d->u->wst, "Working-stack");
+			inspect(&d->u->rst, "Return-stack");
+			break;
+		case 0xf: return 0;
+		}
+	}
+	return 1;
+}
+
+static int
+console_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(b0 == 0x1)
+		d->vector = peek16(d->dat, 0x0);
+	if(w && b0 > 0x7)
+		write(b0 - 0x7, (char *)&d->dat[b0], 1);
+	return 1;
+}
+
+static int
+file_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	Uint8 read = b0 == 0xd;
+	if(w && (read || b0 == 0xf)) {
+		char *name = (char *)&d->mem[peek16(d->dat, 0x8)];
+		Uint16 result = 0, length = peek16(d->dat, 0xa);
+		long offset = (peek16(d->dat, 0x4) << 16) + peek16(d->dat, 0x6);
+		Uint16 addr = peek16(d->dat, b0 - 1);
+		FILE *f = fopen(name, read ? "rb" : (offset ? "ab" : "wb"));
+		if(f) {
+			if(fseek(f, offset, SEEK_SET) != -1)
+				result = read ? fread(&d->mem[addr], 1, length, f) : fwrite(&d->mem[addr], 1, length, f);
+			fclose(f);
+		}
+		poke16(d->dat, 0x2, result);
+	}
+	return 1;
+}
+
+static int
+datetime_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	time_t seconds = time(NULL);
+	struct tm *t = localtime(&seconds);
+	t->tm_year += 1900;
+	poke16(d->dat, 0x0, t->tm_year);
+	d->dat[0x2] = t->tm_mon;
+	d->dat[0x3] = t->tm_mday;
+	d->dat[0x4] = t->tm_hour;
+	d->dat[0x5] = t->tm_min;
+	d->dat[0x6] = t->tm_sec;
+	d->dat[0x7] = t->tm_wday;
+	poke16(d->dat, 0x08, t->tm_yday);
+	d->dat[0xa] = t->tm_isdst;
+	(void)b0;
+	(void)w;
+	return 1;
+}
+
+static int
+nil_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	(void)d;
+	(void)b0;
+	(void)w;
+	return 1;
+}
+
+#pragma mark - Generics
+
+static const char *errors[] = {"underflow", "overflow", "division by zero"};
+
+int
+uxn_halt(Uxn *u, Uint8 error, char *name, int id)
+{
+	fprintf(stderr, "Halted: %s %s#%04x, at 0x%04x\n", name, errors[error - 1], id, u->ram.ptr);
+	return 0;
+}
+
+static int
+console_input(Uxn *u, char c)
+{
+	devconsole->dat[0x2] = c;
+	return uxn_eval(u, devconsole->vector);
+}
+
+static void
+run(Uxn *u)
+{
+	Uint16 vec;
+	while((!u->dev[0].dat[0xf]) && (read(0, &devconsole->dat[0x2], 1) > 0)) {
+		vec = peek16(devconsole->dat, 0);
+		if(!vec) vec = u->ram.ptr; /* continue after last BRK */
+		uxn_eval(u, vec);
+	}
+}
+
+static int
+load(Uxn *u, char *filepath)
+{
+	FILE *f;
+	if(!(f = fopen(filepath, "rb")))
+		return 0;
+	fread(u->ram.dat + PAGE_PROGRAM, sizeof(u->ram.dat) - PAGE_PROGRAM, 1, f);
+	fprintf(stderr, "Loaded %s\n", filepath);
+	return 1;
+}
+
+int
+main(int argc, char **argv)
+{
+	Uxn u;
+	int i, loaded = 0;
+
+	if(!uxn_boot(&u))
+		return error("Boot", "Failed");
+
+	/* system   */ devsystem = uxn_port(&u, 0x0, system_talk);
+	/* console  */ devconsole = uxn_port(&u, 0x1, console_talk);
+	/* empty    */ uxn_port(&u, 0x2, nil_talk);
+	/* empty    */ uxn_port(&u, 0x3, nil_talk);
+	/* empty    */ uxn_port(&u, 0x4, nil_talk);
+	/* empty    */ uxn_port(&u, 0x5, nil_talk);
+	/* empty    */ uxn_port(&u, 0x6, nil_talk);
+	/* empty    */ uxn_port(&u, 0x7, nil_talk);
+	/* empty    */ uxn_port(&u, 0x8, nil_talk);
+	/* empty    */ uxn_port(&u, 0x9, nil_talk);
+	/* file     */ uxn_port(&u, 0xa, file_talk);
+	/* datetime */ uxn_port(&u, 0xb, datetime_talk);
+	/* empty    */ uxn_port(&u, 0xc, nil_talk);
+	/* empty    */ uxn_port(&u, 0xd, nil_talk);
+	/* empty    */ uxn_port(&u, 0xe, nil_talk);
+	/* empty    */ uxn_port(&u, 0xf, nil_talk);
+
+	for(i = 1; i < argc; ++i) {
+		if(!loaded++) {
+			if(!load(&u, argv[i]))
+				return error("Load", "Failed");
+			if(!uxn_eval(&u, PAGE_PROGRAM))
+				return error("Init", "Failed");
+		} else {
+			char *p = argv[i];
+			while(*p) console_input(&u, *p++);
+			console_input(&u, '\n');
+		}
+	}
+	if(!loaded)
+		return error("Input", "Missing");
+
+	run(&u);
+
+	return 0;
+}
diff --git a/apps/plugins/varvara/uxnemu.c b/apps/plugins/varvara/uxnemu.c
new file mode 100644
index 0000000000..6aae2dcf7a
--- /dev/null
+++ b/apps/plugins/varvara/uxnemu.c
@@ -0,0 +1,624 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <time.h>
+#include "uxn.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#include <SDL.h>
+#include "devices/ppu.h"
+#include "devices/apu.h"
+#pragma GCC diagnostic pop
+
+/*
+Copyright (c) 2021 Devine Lu Linvega
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+#define WIDTH 64 * 8
+#define HEIGHT 40 * 8
+#define PAD 4
+#define FIXED_SIZE 0
+#define POLYPHONY 4
+#define BENCH 0
+
+static SDL_Window *gWindow;
+static SDL_Texture *gTexture;
+static SDL_Renderer *gRenderer;
+static SDL_AudioDeviceID audio_id;
+static SDL_Rect gRect;
+/* devices */
+static Ppu ppu;
+static Apu apu[POLYPHONY];
+static Device *devsystem, *devscreen, *devmouse, *devctrl, *devaudio0, *devconsole;
+static Uint8 zoom = 1;
+static Uint32 *ppu_screen, stdin_event, audio0_event, palette[16];
+
+static Uint8 font[][8] = {
+	{0x00, 0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c},
+	{0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
+	{0x00, 0x7c, 0x82, 0x02, 0x7c, 0x80, 0x80, 0xfe},
+	{0x00, 0x7c, 0x82, 0x02, 0x1c, 0x02, 0x82, 0x7c},
+	{0x00, 0x0c, 0x14, 0x24, 0x44, 0x84, 0xfe, 0x04},
+	{0x00, 0xfe, 0x80, 0x80, 0x7c, 0x02, 0x82, 0x7c},
+	{0x00, 0x7c, 0x82, 0x80, 0xfc, 0x82, 0x82, 0x7c},
+	{0x00, 0x7c, 0x82, 0x02, 0x1e, 0x02, 0x02, 0x02},
+	{0x00, 0x7c, 0x82, 0x82, 0x7c, 0x82, 0x82, 0x7c},
+	{0x00, 0x7c, 0x82, 0x82, 0x7e, 0x02, 0x82, 0x7c},
+	{0x00, 0x7c, 0x82, 0x02, 0x7e, 0x82, 0x82, 0x7e},
+	{0x00, 0xfc, 0x82, 0x82, 0xfc, 0x82, 0x82, 0xfc},
+	{0x00, 0x7c, 0x82, 0x80, 0x80, 0x80, 0x82, 0x7c},
+	{0x00, 0xfc, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfc},
+	{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
+	{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
+
+static int
+clamp(int val, int min, int max)
+{
+	return (val >= min) ? (val <= max) ? val : max : min;
+}
+
+static int
+error(char *msg, const char *err)
+{
+	fprintf(stderr, "%s: %s\n", msg, err);
+	return 0;
+}
+
+#pragma mark - Generics
+
+static void
+audio_callback(void *u, Uint8 *stream, int len)
+{
+	int i, running = 0;
+	Sint16 *samples = (Sint16 *)stream;
+	SDL_memset(stream, 0, len);
+	for(i = 0; i < POLYPHONY; ++i)
+		running += apu_render(&apu[i], samples, samples + len / 2);
+	if(!running)
+		SDL_PauseAudioDevice(audio_id, 1);
+	(void)u;
+}
+
+void
+apu_finished_handler(Apu *c)
+{
+	SDL_Event event;
+	event.type = audio0_event + (c - apu);
+	SDL_PushEvent(&event);
+}
+
+static int
+stdin_handler(void *p)
+{
+	SDL_Event event;
+	event.type = stdin_event;
+	while(read(0, &event.cbutton.button, 1) > 0)
+		SDL_PushEvent(&event);
+	return 0;
+	(void)p;
+}
+
+void
+set_palette(Uint8 *addr)
+{
+	int i;
+	for(i = 0; i < 4; ++i) {
+		Uint8
+			r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f,
+			g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f,
+			b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f;
+		palette[i] = 0xff000000 | (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
+	}
+	for(i = 4; i < 16; ++i)
+		palette[i] = palette[i / 4];
+	ppu.reqdraw = 1;
+}
+
+static void
+set_window_size(SDL_Window *window, int w, int h)
+{
+	SDL_Point win, win_old;
+	SDL_GetWindowPosition(window, &win.x, &win.y);
+	SDL_GetWindowSize(window, &win_old.x, &win_old.y);
+	SDL_SetWindowPosition(window, (win.x + win_old.x / 2) - w / 2, (win.y + win_old.y / 2) - h / 2);
+	SDL_SetWindowSize(window, w, h);
+}
+
+static void
+set_zoom(Uint8 scale)
+{
+	zoom = clamp(scale, 1, 3);
+	if(!gWindow)
+		return;
+	set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
+	ppu.reqdraw = 1;
+}
+
+static int
+set_size(Uint16 width, Uint16 height, int is_resize)
+{
+	ppu_set_size(&ppu, width, height);
+	gRect.x = PAD;
+	gRect.y = PAD;
+	gRect.w = ppu.width;
+	gRect.h = ppu.height;
+	if(!(ppu_screen = realloc(ppu_screen, ppu.width * ppu.height * sizeof(Uint32))))
+		return error("ppu_screen", "Memory failure");
+	memset(ppu_screen, 0, ppu.width * ppu.height * sizeof(Uint32));
+	if(gTexture != NULL) SDL_DestroyTexture(gTexture);
+	SDL_RenderSetLogicalSize(gRenderer, ppu.width + PAD * 2, ppu.height + PAD * 2);
+	gTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, ppu.width + PAD * 2, ppu.height + PAD * 2);
+	if(gTexture == NULL || SDL_SetTextureBlendMode(gTexture, SDL_BLENDMODE_NONE))
+		return error("gTexture", SDL_GetError());
+	if(SDL_UpdateTexture(gTexture, NULL, ppu_screen, sizeof(Uint32)) != 0)
+		return error("SDL_UpdateTexture", SDL_GetError());
+	if(is_resize)
+		set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
+	ppu.reqdraw = 1;
+	return 1;
+}
+
+static void
+capture_screen(void)
+{
+	const Uint32 format = SDL_PIXELFORMAT_RGB24;
+	time_t t = time(NULL);
+	char fname[64];
+	int w, h;
+	SDL_Surface *surface;
+	SDL_GetRendererOutputSize(gRenderer, &w, &h);
+	surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 24, format);
+	SDL_RenderReadPixels(gRenderer, NULL, format, surface->pixels, surface->pitch);
+	strftime(fname, sizeof(fname), "screenshot-%Y%m%d-%H%M%S.bmp", localtime(&t));
+	SDL_SaveBMP(surface, fname);
+	SDL_FreeSurface(surface);
+	fprintf(stderr, "Saved %s\n", fname);
+}
+
+static void
+draw_inspect(Ppu *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory)
+{
+	Uint8 i, x, y, b;
+	for(i = 0; i < 0x20; ++i) {
+		x = ((i % 8) * 3 + 1) * 8, y = (i / 8 + 1) * 8, b = stack[i];
+		/* working stack */
+		ppu_1bpp(p, 1, x, y, font[(b >> 4) & 0xf], 1 + (wptr == i) * 0x7, 0, 0);
+		ppu_1bpp(p, 1, x + 8, y, font[b & 0xf], 1 + (wptr == i) * 0x7, 0, 0);
+		y = 0x28 + (i / 8 + 1) * 8;
+		b = memory[i];
+		/* return stack */
+		ppu_1bpp(p, 1, x, y, font[(b >> 4) & 0xf], 3, 0, 0);
+		ppu_1bpp(p, 1, x + 8, y, font[b & 0xf], 3, 0, 0);
+	}
+	/* return pointer */
+	ppu_1bpp(p, 1, 0x8, y + 0x10, font[(rptr >> 4) & 0xf], 0x2, 0, 0);
+	ppu_1bpp(p, 1, 0x10, y + 0x10, font[rptr & 0xf], 0x2, 0, 0);
+	/* guides */
+	for(x = 0; x < 0x10; ++x) {
+		ppu_write(p, 1, x, p->height / 2, 2);
+		ppu_write(p, 1, p->width - x, p->height / 2, 2);
+		ppu_write(p, 1, p->width / 2, p->height - x, 2);
+		ppu_write(p, 1, p->width / 2, x, 2);
+		ppu_write(p, 1, p->width / 2 - 0x10 / 2 + x, p->height / 2, 2);
+		ppu_write(p, 1, p->width / 2, p->height / 2 - 0x10 / 2 + x, 2);
+	}
+}
+
+static void
+redraw(Uxn *u)
+{
+	Uint16 x, y;
+	if(devsystem->dat[0xe])
+		draw_inspect(&ppu, u->wst.dat, u->wst.ptr, u->rst.ptr, u->ram.dat);
+	for(y = 0; y < ppu.height; ++y)
+		for(x = 0; x < ppu.width; ++x)
+			ppu_screen[x + y * ppu.width] = palette[ppu_read(&ppu, x, y)];
+	if(SDL_UpdateTexture(gTexture, &gRect, ppu_screen, ppu.width * sizeof(Uint32)) != 0)
+		error("SDL_UpdateTexture", SDL_GetError());
+	SDL_RenderClear(gRenderer);
+	SDL_RenderCopy(gRenderer, gTexture, NULL, NULL);
+	SDL_RenderPresent(gRenderer);
+	ppu.reqdraw = 0;
+}
+
+static void
+quit(void)
+{
+	if(audio_id)
+		SDL_CloseAudioDevice(audio_id);
+	SDL_DestroyTexture(gTexture);
+	gTexture = NULL;
+	SDL_DestroyRenderer(gRenderer);
+	gRenderer = NULL;
+	SDL_DestroyWindow(gWindow);
+	SDL_Quit();
+	exit(0);
+}
+
+static int
+init(void)
+{
+	SDL_AudioSpec as;
+	SDL_zero(as);
+	as.freq = SAMPLE_FREQUENCY;
+	as.format = AUDIO_S16;
+	as.channels = 2;
+	as.callback = audio_callback;
+	as.samples = 512;
+	as.userdata = NULL;
+	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
+		error("sdl", SDL_GetError());
+		if(SDL_Init(SDL_INIT_VIDEO) < 0)
+			return error("sdl", SDL_GetError());
+	} else {
+		audio_id = SDL_OpenAudioDevice(NULL, 0, &as, NULL, 0);
+		if(!audio_id)
+			error("sdl_audio", SDL_GetError());
+	}
+	gWindow = SDL_CreateWindow("Uxn", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, (WIDTH + PAD * 2) * zoom, (HEIGHT + PAD * 2) * zoom, SDL_WINDOW_SHOWN);
+	if(gWindow == NULL)
+		return error("sdl_window", SDL_GetError());
+	gRenderer = SDL_CreateRenderer(gWindow, -1, 0);
+	if(gRenderer == NULL)
+		return error("sdl_renderer", SDL_GetError());
+	stdin_event = SDL_RegisterEvents(1);
+	audio0_event = SDL_RegisterEvents(POLYPHONY);
+	SDL_CreateThread(stdin_handler, "stdin", NULL);
+	SDL_StartTextInput();
+	SDL_ShowCursor(SDL_DISABLE);
+	return 1;
+}
+
+static void
+domouse(SDL_Event *event)
+{
+	Uint8 flag = 0x00;
+	Uint16 x = clamp(event->motion.x - PAD, 0, ppu.width - 1);
+	Uint16 y = clamp(event->motion.y - PAD, 0, ppu.height - 1);
+	if(event->type == SDL_MOUSEWHEEL) {
+		devmouse->dat[7] = event->wheel.y;
+		return;
+	}
+	poke16(devmouse->dat, 0x2, x);
+	poke16(devmouse->dat, 0x4, y);
+	devmouse->dat[7] = 0x00;
+	switch(event->button.button) {
+	case SDL_BUTTON_LEFT: flag = 0x01; break;
+	case SDL_BUTTON_RIGHT: flag = 0x10; break;
+	}
+	switch(event->type) {
+	case SDL_MOUSEBUTTONDOWN:
+		devmouse->dat[6] |= flag;
+		break;
+	case SDL_MOUSEBUTTONUP:
+		devmouse->dat[6] &= (~flag);
+		break;
+	}
+}
+
+static void
+doctrl(SDL_Event *event, int z)
+{
+	Uint8 flag = 0x00;
+	SDL_Keymod mods = SDL_GetModState();
+	devctrl->dat[2] &= 0xf8;
+	if(mods & KMOD_CTRL) devctrl->dat[2] |= 0x01;
+	if(mods & KMOD_ALT) devctrl->dat[2] |= 0x02;
+	if(mods & KMOD_SHIFT) devctrl->dat[2] |= 0x04;
+	/* clang-format off */
+	switch(event->key.keysym.sym) {
+	case SDLK_ESCAPE: flag = 0x08; break;
+	case SDLK_UP: flag = 0x10; break;
+	case SDLK_DOWN: flag = 0x20; break;
+	case SDLK_LEFT: flag = 0x40; break;
+	case SDLK_RIGHT: flag = 0x80; break;
+	case SDLK_F1: if(z) set_zoom(zoom > 2 ? 1 : zoom + 1); break;
+	case SDLK_F2: if(z) devsystem->dat[0xe] = !devsystem->dat[0xe]; break;
+	case SDLK_F3: if(z) capture_screen(); break;
+	}
+	/* clang-format on */
+	if(z) {
+		devctrl->dat[2] |= flag;
+		if(event->key.keysym.sym < 0x20 || event->key.keysym.sym == SDLK_DELETE)
+			devctrl->dat[3] = event->key.keysym.sym;
+		else if((mods & KMOD_CTRL) && event->key.keysym.sym >= SDLK_a && event->key.keysym.sym <= SDLK_z)
+			devctrl->dat[3] = event->key.keysym.sym - (mods & KMOD_SHIFT) * 0x20;
+	} else
+		devctrl->dat[2] &= ~flag;
+}
+
+#pragma mark - Devices
+
+static int
+system_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(!w) { /* read */
+		switch(b0) {
+		case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
+		case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
+		}
+	} else { /* write */
+		switch(b0) {
+		case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
+		case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
+		case 0xf: return 0;
+		}
+		if(b0 > 0x7 && b0 < 0xe)
+			set_palette(&d->dat[0x8]);
+	}
+	return 1;
+}
+
+static int
+console_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(w) {
+		if(b0 == 0x1)
+			d->vector = peek16(d->dat, 0x0);
+		if(b0 > 0x7)
+			write(b0 - 0x7, (char *)&d->dat[b0], 1);
+	}
+	return 1;
+}
+
+static int
+screen_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(!w) switch(b0) {
+		case 0x2: d->dat[0x2] = ppu.width >> 8; break;
+		case 0x3: d->dat[0x3] = ppu.width; break;
+		case 0x4: d->dat[0x4] = ppu.height >> 8; break;
+		case 0x5: d->dat[0x5] = ppu.height; break;
+		}
+	else
+		switch(b0) {
+		case 0x1: d->vector = peek16(d->dat, 0x0); break;
+		case 0x5:
+			if(!FIXED_SIZE) return set_size(peek16(d->dat, 0x2), peek16(d->dat, 0x4), 1);
+			break;
+		case 0xe: {
+			Uint16 x = peek16(d->dat, 0x8);
+			Uint16 y = peek16(d->dat, 0xa);
+			Uint8 layer = d->dat[0xe] & 0x40;
+			ppu_write(&ppu, !!layer, x, y, d->dat[0xe] & 0x3);
+			if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 1); /* auto x+1 */
+			if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 1); /* auto y+1 */
+			break;
+		}
+		case 0xf: {
+			Uint16 x = peek16(d->dat, 0x8);
+			Uint16 y = peek16(d->dat, 0xa);
+			Uint8 layer = d->dat[0xf] & 0x40;
+			Uint8 *addr = &d->mem[peek16(d->dat, 0xc)];
+			if(d->dat[0xf] & 0x80) {
+				ppu_2bpp(&ppu, !!layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
+				if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 16); /* auto addr+16 */
+			} else {
+				ppu_1bpp(&ppu, !!layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
+				if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 8); /* auto addr+8 */
+			}
+			if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 8); /* auto x+8 */
+			if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 8); /* auto y+8 */
+			break;
+		}
+		}
+	return 1;
+}
+
+static int
+file_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	Uint8 read = b0 == 0xd;
+	if(w && (read || b0 == 0xf)) {
+		char *name = (char *)&d->mem[peek16(d->dat, 0x8)];
+		Uint16 result = 0, length = peek16(d->dat, 0xa);
+		long offset = (peek16(d->dat, 0x4) << 16) + peek16(d->dat, 0x6);
+		Uint16 addr = peek16(d->dat, b0 - 1);
+		FILE *f = fopen(name, read ? "rb" : (offset ? "ab" : "wb"));
+		if(f) {
+			if(fseek(f, offset, SEEK_SET) != -1)
+				result = read ? fread(&d->mem[addr], 1, length, f) : fwrite(&d->mem[addr], 1, length, f);
+			fclose(f);
+		}
+		poke16(d->dat, 0x2, result);
+	}
+	return 1;
+}
+
+static int
+audio_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	Apu *c = &apu[d - devaudio0];
+	if(!audio_id) return 1;
+	if(!w) {
+		if(b0 == 0x2)
+			poke16(d->dat, 0x2, c->i);
+		else if(b0 == 0x4)
+			d->dat[0x4] = apu_get_vu(c);
+	} else if(b0 == 0xf) {
+		SDL_LockAudioDevice(audio_id);
+		c->len = peek16(d->dat, 0xa);
+		c->addr = &d->mem[peek16(d->dat, 0xc)];
+		c->volume[0] = d->dat[0xe] >> 4;
+		c->volume[1] = d->dat[0xe] & 0xf;
+		c->repeat = !(d->dat[0xf] & 0x80);
+		apu_start(c, peek16(d->dat, 0x8), d->dat[0xf] & 0x7f);
+		SDL_UnlockAudioDevice(audio_id);
+		SDL_PauseAudioDevice(audio_id, 0);
+	}
+	return 1;
+}
+
+static int
+datetime_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	time_t seconds = time(NULL);
+	struct tm *t = localtime(&seconds);
+	t->tm_year += 1900;
+	poke16(d->dat, 0x0, t->tm_year);
+	d->dat[0x2] = t->tm_mon;
+	d->dat[0x3] = t->tm_mday;
+	d->dat[0x4] = t->tm_hour;
+	d->dat[0x5] = t->tm_min;
+	d->dat[0x6] = t->tm_sec;
+	d->dat[0x7] = t->tm_wday;
+	poke16(d->dat, 0x08, t->tm_yday);
+	d->dat[0xa] = t->tm_isdst;
+	(void)b0;
+	(void)w;
+	return 1;
+}
+
+static int
+nil_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(w && b0 == 0x1)
+		d->vector = peek16(d->dat, 0x0);
+	(void)d;
+	(void)b0;
+	(void)w;
+	return 1;
+}
+
+static const char *errors[] = {"underflow", "overflow", "division by zero"};
+
+int
+uxn_halt(Uxn *u, Uint8 error, char *name, int id)
+{
+	fprintf(stderr, "Halted: %s %s#%04x, at 0x%04x\n", name, errors[error - 1], id, u->ram.ptr);
+	return 0;
+}
+
+static int
+console_input(Uxn *u, char c)
+{
+	devconsole->dat[0x2] = c;
+	return uxn_eval(u, devconsole->vector);
+}
+
+static int
+run(Uxn *u)
+{
+	redraw(u);
+	while(!devsystem->dat[0xf]) {
+		SDL_Event event;
+		double elapsed, start = 0;
+		if(!BENCH)
+			start = SDL_GetPerformanceCounter();
+		while(SDL_PollEvent(&event) != 0) {
+			switch(event.type) {
+			case SDL_QUIT:
+				return error("Run", "Quit.");
+			case SDL_TEXTINPUT:
+				devctrl->dat[3] = event.text.text[0]; /* fall-thru */
+			case SDL_KEYDOWN:
+			case SDL_KEYUP:
+				doctrl(&event, event.type == SDL_KEYDOWN);
+				uxn_eval(u, devctrl->vector);
+				devctrl->dat[3] = 0;
+				break;
+			case SDL_MOUSEWHEEL:
+			case SDL_MOUSEBUTTONUP:
+			case SDL_MOUSEBUTTONDOWN:
+			case SDL_MOUSEMOTION:
+				domouse(&event);
+				uxn_eval(u, devmouse->vector);
+				break;
+			case SDL_WINDOWEVENT:
+				if(event.window.event == SDL_WINDOWEVENT_EXPOSED)
+					redraw(u);
+				break;
+			default:
+				if(event.type == stdin_event) {
+					console_input(u, event.cbutton.button);
+				} else if(event.type >= audio0_event && event.type < audio0_event + POLYPHONY)
+					uxn_eval(u, peek16((devaudio0 + (event.type - audio0_event))->dat, 0));
+			}
+		}
+		uxn_eval(u, devscreen->vector);
+		if(ppu.reqdraw || devsystem->dat[0xe])
+			redraw(u);
+		if(!BENCH) {
+			elapsed = (SDL_GetPerformanceCounter() - start) / (double)SDL_GetPerformanceFrequency() * 1000.0f;
+			SDL_Delay(clamp(16.666f - elapsed, 0, 1000));
+		}
+	}
+	return error("Run", "Ended.");
+}
+
+static int
+load(Uxn *u, char *filepath)
+{
+	FILE *f;
+	if(!(f = fopen(filepath, "rb"))) return 0;
+	fread(u->ram.dat + PAGE_PROGRAM, sizeof(u->ram.dat) - PAGE_PROGRAM, 1, f);
+	fprintf(stderr, "Loaded %s\n", filepath);
+	return 1;
+}
+
+int
+main(int argc, char **argv)
+{
+	SDL_DisplayMode DM;
+	Uxn u;
+	int i, loaded = 0;
+
+	if(!uxn_boot(&u))
+		return error("Boot", "Failed to start uxn.");
+
+	/* system   */ devsystem = uxn_port(&u, 0x0, system_talk);
+	/* console  */ devconsole = uxn_port(&u, 0x1, console_talk);
+	/* screen   */ devscreen = uxn_port(&u, 0x2, screen_talk);
+	/* audio0   */ devaudio0 = uxn_port(&u, 0x3, audio_talk);
+	/* audio1   */ uxn_port(&u, 0x4, audio_talk);
+	/* audio2   */ uxn_port(&u, 0x5, audio_talk);
+	/* audio3   */ uxn_port(&u, 0x6, audio_talk);
+	/* unused   */ uxn_port(&u, 0x7, nil_talk);
+	/* control  */ devctrl = uxn_port(&u, 0x8, nil_talk);
+	/* mouse    */ devmouse = uxn_port(&u, 0x9, nil_talk);
+	/* file     */ uxn_port(&u, 0xa, file_talk);
+	/* datetime */ uxn_port(&u, 0xb, datetime_talk);
+	/* unused   */ uxn_port(&u, 0xc, nil_talk);
+	/* unused   */ uxn_port(&u, 0xd, nil_talk);
+	/* unused   */ uxn_port(&u, 0xe, nil_talk);
+	/* unused   */ uxn_port(&u, 0xf, nil_talk);
+
+	/* set default zoom */
+	if(SDL_GetCurrentDisplayMode(0, &DM) == 0)
+		set_zoom(DM.w / 1280);
+	for(i = 1; i < argc; ++i) {
+		/* get default zoom from flags */
+		if(strcmp(argv[i], "-s") == 0) {
+			if(i < argc - 1)
+				set_zoom(atoi(argv[++i]));
+			else
+				return error("Opt", "-s No scale provided.");
+		} else if(!loaded++) {
+			if(!load(&u, argv[i]))
+				return error("Load", "Failed to open rom.");
+			if(!init())
+				return error("Init", "Failed to initialize emulator.");
+			if(!set_size(WIDTH, HEIGHT, 0))
+				return error("Window", "Failed to set window size.");
+			if(!uxn_eval(&u, PAGE_PROGRAM))
+				return error("Init", "Failed");
+		} else {
+			char *p = argv[i];
+			while(*p) console_input(&u, *p++);
+			console_input(&u, '\n');
+		}
+	}
+	if(!loaded)
+		return error("usage", "uxnemu file.rom");
+
+	run(&u);
+	quit();
+	return 0;
+}
diff --git a/apps/plugins/varvara/varvara.c b/apps/plugins/varvara/varvara.c
new file mode 100644
index 0000000000..5821a6d93b
--- /dev/null
+++ b/apps/plugins/varvara/varvara.c
@@ -0,0 +1,153 @@
+/* Varvara plugin for rockbox. I have no idea what I'm doing. */
+
+#include "uxn.h"
+#include "devices/ppu.h"
+#include "plugin.h"
+#include <stdio.h>
+#include <stdint.h>
+#include <time.h>
+
+
+const uint8_t uxn_rom[] = { /* hello world ROM */
+    0x20, 0x01, 0x0e, 0x94, 0x80, 0x18, 0x17, 0x21,
+    0x94, 0x80, 0xf7, 0x0d, 0x22, 0x00, 0x48, 0x65,
+    0x6c, 0x6c, 0x6f, 0x20, 0x55, 0x78, 0x6e, 0x21,
+    0x21, 
+};
+
+static Uxn u;
+static Device *devsystem, *devconsole;
+
+static void
+memzero8(void *src, uint64_t n) 
+{
+    uint8_t * ptr = src;
+    for (size_t i = 0; i < n; i++) {
+        ptr[i] = 0;
+    }
+}
+
+/* taken from uxncli */
+static void
+inspect(Stack *s, char *name)
+{
+	Uint8 x, y;
+	DEBUGF("\n%s\n", name);
+	for(y = 0; y < 0x04; ++y) {
+		for(x = 0; x < 0x08; ++x) {
+			Uint8 p = y * 0x08 + x;
+			DEBUGF(p == s->ptr ? "[%02x]" : " %02x ",
+				s->dat[p]);
+		}
+		DEBUGF("\n");
+	}
+}
+
+/* taken from uxncli */
+static int
+system_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(!w) { /* read */
+		switch(b0) {
+		case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
+		case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
+		}
+	} else { /* write */
+		switch(b0) {
+		case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
+		case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
+		case 0xe:
+			inspect(&d->u->wst, "Working-stack");
+			inspect(&d->u->rst, "Return-stack");
+			break;
+		case 0xf: return 0;
+		}
+	}
+	return 1;
+}
+
+/* taken from uxncli */
+static int
+console_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	if(b0 == 0x1)
+		d->vector = peek16(d->dat, 0x0);
+	if(w && b0 > 0x7)
+		DEBUGF("%c",(char *)&d->dat[b0]);
+	return 1;
+}
+
+static int
+nil_talk(Device *d, Uint8 b0, Uint8 w)
+{
+	(void)d;
+	(void)b0;
+	(void)w;
+	return 1;
+}
+
+int
+uxn_halt(Uxn *u, Uint8 error, char *name, int id)
+{
+	DEBUGF("Halted");
+	return 0;
+}
+
+/* this is the plugin entry point */
+enum plugin_status plugin_start(const void* parameter)
+{
+    /* if you don't use the parameter, you can do like
+       this to avoid the compiler warning about it */
+    (void)parameter;
+
+    /* "rb->" marks a plugin api call. Rockbox offers many of its built-in
+     * functions to plugins */
+    /* now go ahead and have fun! */
+    DEBUGF("UXN init\n");
+        // Clear RAM and copy rom to VM.
+    DEBUGF("zeroing\n");
+    memzero8(&u, sizeof(Uxn));
+    DEBUGF("copying ROM\n");
+    memcpy(u.ram.dat + PAGE_PROGRAM, uxn_rom, sizeof(uxn_rom));
+    DEBUGF("registering ports\n");
+    // Register ports
+    /* system   */ devsystem = uxn_port(&u, 0x0, system_talk);
+	/* console  */ devconsole = uxn_port(&u, 0x1, console_talk);
+	/* screen   */ uxn_port(&u, 0x2, nil_talk);
+	/* audio0   */ uxn_port(&u, 0x3, nil_talk);
+	/* audio1   */ uxn_port(&u, 0x4, nil_talk);
+	/* audio2   */ uxn_port(&u, 0x5, nil_talk);
+	/* audio3   */ uxn_port(&u, 0x6, nil_talk);
+	/* empty    */ uxn_port(&u, 0x7, nil_talk);
+	/* control  */ uxn_port(&u, 0x8, nil_talk);
+	/* mouse    */ uxn_port(&u, 0x9, nil_talk);
+	/* file     */ uxn_port(&u, 0xa, nil_talk);
+	/* datetime */ uxn_port(&u, 0xb, nil_talk);
+	/* empty    */ uxn_port(&u, 0xc, nil_talk);
+	/* empty    */ uxn_port(&u, 0xd, nil_talk);
+	/* empty    */ uxn_port(&u, 0xe, nil_talk);
+	/* empty    */ uxn_port(&u, 0xf, nil_talk);
+	
+    // Boot
+    // if(!uxn_boot(&u))
+    //		return -1;
+    // Run
+    DEBUGF("eval\n");
+    uxn_eval(&u, 0x0100);
+
+	rb->lcd_clear_display();
+	// 0x000f: blue, 0x00f0: 
+	//rb->lcd_set_foreground(LCD_RGBPACK(0,0,255));
+	rb->lcd_fillrect(0,0,10,10);
+	//rb->lcd_set_foreground(0x00f0);
+	rb->lcd_fillrect(10,0,10,10);
+	//rb->lcd_set_foreground(0x0f00);
+	rb->lcd_fillrect(20,0,10,10);
+	//rb->lcd_set_foreground(0xf000);
+	rb->lcd_fillrect(30,0,10,10);
+	rb->lcd_update();
+
+	rb->button_get(true);
+	return PLUGIN_OK;
+
+}
diff --git a/apps/plugins/varvara/varvara.make b/apps/plugins/varvara/varvara.make
new file mode 100644
index 0000000000..0a390eb1ca
--- /dev/null
+++ b/apps/plugins/varvara/varvara.make
@@ -0,0 +1,21 @@
+#             __________               __   ___.
+#   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+#   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+#   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+#   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+#                     \/            \/     \/    \/            \/
+# $Id$
+#
+
+VARVARASRCDIR := $(APPSDIR)/plugins/varvara
+VARVARABUILDDIR := $(BUILDDIR)/apps/plugins/varvara
+
+ROCKS += $(VARVARABUILDDIR)/varvara.rock
+
+VARVARA_SRC := $(call preprocess, $(VARVARASRCDIR)/SOURCES)
+VARVARA_OBJ := $(call c2obj, $(VARVARA_SRC))
+
+# add source files to OTHER_SRC to get automatic dependencies
+OTHER_SRC += $(VARVARA_SRC)
+
+$(VARVARABUILDDIR)/varvara.rock: $(VARVARA_OBJ)