Added GPLv2.

We're now Free Software!!!

1 files changed, 354 insertions, 876 deletions

diff --git a/sux.c b/sux.c
index 85280c1..1fc8fe2 100644
--- a/sux.c
+++ b/sux.c
@@ -1,15 +1,16 @@
 #include "opcode.h"
 #include <assert.h>
-#include <curses.h>
 #include <ctype.h>
 #include <string.h>
 #include <pthread.h>
 #define bench 0
-#define debug 1
-#define IO 0
+#define debug 0
+#define IO 1
 #define keypoll 0
 #if bench
 #include <sys/time.h>
+#else
+#include <curses.h>
 #endif
 
 #define THREADS	1
@@ -27,7 +28,9 @@ uint8_t threads_done = 0;
 uint8_t kbd_rdy = 0;
 uint8_t wai = 0;
 uint8_t irq = 0;
+#if !bench
 WINDOW *scr;
+#endif
 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 pthread_mutex_t main_mutex = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
@@ -46,21 +49,26 @@ void *run(void *args) {
 	struct sux *cpu = &thr->sx;
 	uint8_t thread = thr->th;
 	uint64_t address = 0;
+	uint64_t tmpaddr = 0;
 	uint8_t prefix = 0;
 	uint8_t opcode = 0;
 	uint8_t end = 0;
+	uint8_t stksize;
 	uint64_t sum = 0;
 	uint64_t value = 0;
+	uint64_t reg = 0;
 	uint64_t iclk = 0;
 	uint64_t ins = 0;
 	uint64_t sign = 0;
 	char *s = malloc(2048);
+#if !bench
 	uint8_t lines = (6*thread)+2;
 	uint8_t bcd[4];
 	uint8_t idx = 3, iscol = 0;
-	uint16_t tv = 0xFF50; /* Starting address of the Thread Vectors. */
 	int x = 0, y = 0;
 	uint8_t esc = 0;
+#endif
+	uint16_t tv = 0xFF50; /* Starting address of the Thread Vectors. */
 #if bench
 	gettimeofday(&str[thread], 0);
 #endif
@@ -90,35 +98,229 @@ void *run(void *args) {
 			kbd_rdy &= (uint8_t)~(1 << thread);
 		}
 		prefix = addr[cpu->pc[thread]];
-		if ((prefix & 0x0F) == 0x07)
+		if ((prefix & 0x07) == 0x07)
 			cpu->pc[thread]++;
 		else
 			prefix = 0;
 		opcode = addr[cpu->pc[thread]];
 
+
 	#if debug && !bench
+		if (lines > 24*(thread+1)) {
+			lines = (24*thread)+2;
+		}
 		#if keypoll
 		pthread_mutex_lock(&mutex);
 		#endif
 		mvwprintw(scr, lines, 0, "pc: $%08llx, a: $%016llx, b: $%016llx, x: $%016llx, y: $%016llx"
-			", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, thread: %u, inst: %s       \r"
+			", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, thread: %u, inst: "
 			, cpu->pc[thread], cpu->a[thread], cpu->b[thread], cpu->x[thread], cpu->y[thread]
-			, cpu->sp[thread], cpu->ps, prefix, opcode, thread, opname[opcode]);
-		wrefresh(scr);
+			, cpu->sp[thread], cpu->ps, prefix, opcode, thread);
 		#if keypoll
 		pthread_mutex_unlock(&mutex);
 		#endif
-		lines++;
-		if (lines > 24*(thread+1))
-			lines = (24*thread)+2;
 	#endif
 
+		uint8_t addrsize = (prefix & 8) == 8;
 		uint8_t rs = (prefix & 0x30) >> 4;
 		uint8_t regsize = (1 << rs);
 		uint8_t tmp;
 		address = cpu->pc[thread];
 		cpu->pc[thread]++;
 		iclk++;
+		switch (optype[opcode]) {
+			case IMPL:
+				break;
+			case IMM:
+				switch (opcode) {
+					case TXS:
+					case PHB:
+					case PHP:
+					case PHA:
+					case PHY:
+					case PHX:
+					case PLB:
+					case PLP:
+					case PLA:
+					case PLY:
+					case PLX:
+						break;
+					case STT:
+					case LSL:
+					case LSR:
+					case ROL:
+					case ROR:
+					case ASR:
+					case ENT:
+						address = cpu->pc[thread];
+						cpu->pc[thread]+=1;
+						break;
+					default:
+						address = cpu->pc[thread];
+						cpu->pc[thread]+=regsize;
+						break;
+				}
+				break;
+			case ZM:
+			case ZMX:
+			case ZMY:
+				address = addr[cpu->pc[thread]];
+				if (addrsize) {
+					address |= addr[cpu->pc[thread]+1] << 8;
+					address |= addr[cpu->pc[thread]+2] << 16;
+					address |= addr[cpu->pc[thread]+3] << 24;
+					cpu->pc[thread]+=4;
+				} else {
+					cpu->pc[thread]+=1;
+				}
+				tmpaddr = address;
+				if (optype[opcode] == ZMX)
+					address += cpu->x[thread];
+				if (optype[opcode] == ZMY)
+					address += cpu->y[thread];
+				break;
+			case IND:
+			case INDX:
+			case INDY:
+				address = addr[cpu->pc[thread]];
+				if (addrsize) {
+					address |= addr[cpu->pc[thread]+1] << 8;
+					address |= addr[cpu->pc[thread]+2] << 16;
+					address |= addr[cpu->pc[thread]+3] << 24;
+					cpu->pc[thread]+=4;
+				} else {
+					cpu->pc[thread]+=1;
+				}
+				tmpaddr = address;
+				if (optype[opcode] == INDX)
+					address += cpu->x[thread];
+				value =		(uint64_t)addr[address]
+						| (uint64_t)addr[address+1] << 8
+						| (uint64_t)addr[address+2] << 16
+						| (uint64_t)addr[address+3] << 24
+						| (uint64_t)addr[address+4] << 32
+						| (uint64_t)addr[address+5] << 40
+						| (uint64_t)addr[address+6] << 48
+						| (uint64_t)addr[address+7] << 56;
+				if (optype[opcode] == INDY)
+					value += cpu->y[thread];
+				address = value;
+				value = 0;
+				iclk++;
+				break;
+			case ABS:
+				address = addr[cpu->pc[thread]];
+				address |= addr[cpu->pc[thread]+1] << 8;
+				if (addrsize) {
+					address |= (uint64_t)addr[cpu->pc[thread]+2] << 16;
+					address |= (uint64_t)addr[cpu->pc[thread]+3] << 24;
+					address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;
+					address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;
+					address |= (uint64_t)addr[cpu->pc[thread]+6] << 48;
+					address |= (uint64_t)addr[cpu->pc[thread]+7] << 56;
+					cpu->pc[thread]+=8;
+					iclk++;
+				} else {
+					cpu->pc[thread]+=2;
+				}
+
+				break;
+
+		}
+		value = addr[address];
+		if (regsize >= 2) {
+			value |= addr[address+1] << 8;
+			if (regsize >= 4) {
+				value |= addr[address+2] << 16;
+				value |= addr[address+3] << 24;
+			}
+			if (regsize >= 8) {
+				value |= (uint64_t)addr[address+4] << 32;
+				value |= (uint64_t)addr[address+5] << 40;
+				value |= (uint64_t)addr[address+6] << 48;
+				value |= (uint64_t)addr[address+7] << 56;
+			}
+		}
+	#if debug && !bench
+		int row, col;
+		#if keypoll
+		pthread_mutex_lock(&mutex);
+		#endif
+		getyx(scr,row, col);
+		char postfix[3];
+		char op[4];
+		op[0] = opname[opcode][0];
+		op[1] = opname[opcode][1];
+		op[2] = opname[opcode][2];
+		op[3] = '\0';
+		if (regsize == 1) {
+			postfix[0] = '\0';
+			postfix[1] = '\0';
+			postfix[2] = '\0';
+		} else {
+			postfix[0] = '.';
+			if (regsize == 2)
+				postfix[1] = 'W';
+			if (regsize == 4)
+				postfix[1] = 'D';
+			if (regsize == 8)
+				postfix[1] = 'Q';
+			postfix[2] = '\0';
+		}
+		switch (optype[opcode]) {
+			case IMPL:
+				mvwprintw(scr, lines, col, "%s                      \r" , opname[opcode]);
+				break;
+			case IMM:
+				if (regsize == 1) {
+					mvwprintw(scr, lines, col, "%s #$%02x                \r" , op, value);
+				}
+				if (regsize == 2) {
+					mvwprintw(scr, lines, col, "%s%s #$%04x            \r" , op, postfix, value);
+				}
+				if (regsize == 4) {
+					mvwprintw(scr, lines, col, "%s%s #$%08x        \r" , op, postfix, value);
+				}
+				if (regsize == 8) {
+					mvwprintw(scr, lines, col, "%s%s #$%016llx\r" , op, postfix, value);
+				}
+				break;
+			case ZM:
+			case ZMX:
+			case ZMY:
+				if (optype[opcode] == ZMX)
+					tmpaddr = address - cpu->x[thread];
+				if (optype[opcode] == ZMY)
+					tmpaddr = address - cpu->y[thread];
+				if (addrsize)
+					mvwprintw(scr, lines, col, "%s%s $%08x%s        \r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y"));
+				else
+					mvwprintw(scr, lines, col, "%s%s $%02x%s        \r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y"));
+				break;
+			case IND:
+			case INDX:
+			case INDY:
+				if (addrsize)
+					mvwprintw(scr, lines, col, "%s%s ($%08x%s        \r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y"));
+				else
+					mvwprintw(scr, lines, col, "%s%s ($%02x%s        \r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y"));
+				break;
+			case ABS:
+				tmpaddr = address;
+				if (addrsize)
+					mvwprintw(scr, lines, col, "%s%s $%016llx\r" , op, postfix, value);
+				else
+					mvwprintw(scr, lines, col, "%s%s $%04x       \r" , op, postfix, tmpaddr);
+				break;
+
+		}
+		mvwprintw(scr, 29, 0, "address: $%016llx\r", address);
+		wrefresh(scr);
+		#if keypoll
+		pthread_mutex_unlock(&mutex);
+		#endif
+		lines+=1;
+	#endif
 		switch(opcode) {
 			case CPS: /* Clear Processor Status. */
 				for (uint8_t i = 0; i < 8; i++) {
@@ -135,48 +337,8 @@ void *run(void *args) {
 			case AAB: /* Add Accumulator with carry by B register. */
 			case 0x03: /* ADC Absolute. */
 			case 0x05: /* ADC Zero Matrix. */
-				if (opcode != AAB) {
-					if (opcode == ADC) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x03) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x05) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-					if (regsize >= 2) {
-						value += (uint64_t)addr[address+1] << 8;
-					}
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+				if (opcode == AAB)
 					value = cpu->b[thread];
-				}
 				sum = cpu->a[thread]+value+cpu->c[thread];
 				cpu->a[thread] = sum;
 				cpu->z[thread] = (sum == 0);
@@ -305,62 +467,13 @@ void *run(void *args) {
 				}
 				break;
 			case JMP: /* JMP Absolute. */
-				address =	(uint64_t)addr[cpu->pc[thread]]
-						| (uint64_t)addr[cpu->pc[thread]+1] << 8
-						| (uint64_t)addr[cpu->pc[thread]+2] << 16
-						| (uint64_t)addr[cpu->pc[thread]+3] << 24
-						| (uint64_t)addr[cpu->pc[thread]+4] << 32
-						| (uint64_t)addr[cpu->pc[thread]+5] << 40
-						| (uint64_t)addr[cpu->pc[thread]+6] << 48
-						| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-				cpu->pc[thread]+=8;
-				iclk++;
 				cpu->pc[thread] = address;
 				break;
 			case SBC: /* SBC Immediate. */
 			case SAB: /* Subtract Accumulator with carry by B register. */
 			case 0x13: /* SBC Absolute. */
 			case 0x15: /* SBC Zero Matrix. */
-				if (opcode != SAB) {
-					if (opcode == SBC) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x13) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x15) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-					if (regsize >= 2) {
-						value += (uint64_t)addr[address+1] << 8;
-					}
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+				if (opcode == SAB) {
 					value = cpu->b[thread];
 				}
 				sum = cpu->a[thread]-value-!cpu->c[thread];
@@ -438,25 +551,10 @@ void *run(void *args) {
 			case 0x44: /* JSR Indexed Indirect. */
 			case 0x54: /* JSR Indirect Indexed. */
 			case JSR: /* Jump to SubRoutine. */
-				address =	(uint64_t)addr[cpu->pc[thread]]
-						| (uint64_t)addr[cpu->pc[thread]+1] << 8
-						| (uint64_t)addr[cpu->pc[thread]+2] << 16
-						| (uint64_t)addr[cpu->pc[thread]+3] << 24;
-				if (opcode == 0x34 || opcode == 0x44 || opcode == 0x54) {
-					address =	(uint64_t)addr[address]
-							| (uint64_t)addr[address+1] << 8
-							| (uint64_t)addr[address+2] << 16
-							| (uint64_t)addr[address+3] << 24
-							| (uint64_t)addr[address+4] << 32
-							| (uint64_t)addr[address+5] << 40
-							| (uint64_t)addr[address+6] << 48
-							| (uint64_t)addr[address+7] << 56;
-					if (opcode == 0x44)
-						address += cpu->x[thread];
-					if (opcode == 0x54)
-						address += cpu->y[thread];
-				}
-				cpu->pc[thread]+=4;
+				if (addrsize)
+					stksize = 24;
+				else
+					stksize = 0;
 				for (int8_t i = 24; i >= 0; i-=8) {
 					if (i)
 						addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> i;
@@ -470,44 +568,8 @@ void *run(void *args) {
 			case ABA: /* bitwise And with Accumulator, and B register. */
 			case 0x23: /* AND Absolute. */
 			case 0x25: /* AND Zero Matrix. */
-				if (opcode != ABA) {
-					if (opcode == AND) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x23) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x25) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = (uint64_t)addr[address];
-					if (regsize >= 2)
-						value += (uint64_t)addr[address+1] << 8;
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
+				if (opcode == ABA) {
+					value = cpu->b[thread];
 				}
 				cpu->a[thread] &= value;
 				cpu->z[thread] = (value == 0);
@@ -516,9 +578,6 @@ void *run(void *args) {
 				(cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread));
 				break;
 			case STT: /* STart Thread. */
-				address = cpu->pc[thread];
-				cpu->pc[thread]++;
-				value = addr[address];
 				cpu->crt |= value;
 				for (uint8_t i = 0; i < 7; i++) {
 					if ((value >> i) & 1) {
@@ -536,25 +595,6 @@ void *run(void *args) {
 				break;
 			case BPO: /* BPO Absolute. */
 			case 0x64: /* BPO Zero Matrix. */
-				if (opcode == BPO) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (cpu->n[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -562,45 +602,7 @@ void *run(void *args) {
 			case OAB: /* bitwise Or with Accumulator, and B register. */
 			case 0x33: /* ORA Absolute. */
 			case 0x35: /* ORA Zero Matrix. */
-				if (opcode != OAB) {
-					if (opcode == ORA) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x39) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x3B) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = (uint64_t)addr[address];
-					if (regsize >= 2)
-						value += (uint64_t)addr[address+1] << 8;
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+				if (opcode == OAB) {
 					value = cpu->b[thread];
 				}
 				cpu->a[thread] |= value;
@@ -615,25 +617,6 @@ void *run(void *args) {
 				break;
 			case BNG: /* BNG Absolute. */
 			case 0x74: /* BNG Zero Matrix. */
-				if (opcode == BNG) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (!cpu->n[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -641,45 +624,7 @@ void *run(void *args) {
 			case XAB: /* bitwise Xor with Accumulator, and B register. */
 			case 0x43: /* XOR Absolute. */
 			case 0x45: /* XOR Zero Matrix. */
-				if (opcode != XAB) {
-					if (opcode == XOR) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x49) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x4B) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = (uint64_t)addr[address];
-					if (regsize >= 2)
-						value += (uint64_t)addr[address+1] << 8;
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+				if (opcode == XAB) {
 					value = cpu->b[thread];
 				}
 				cpu->a[thread] ^= value;
@@ -694,25 +639,6 @@ void *run(void *args) {
 				break;
 			case BCS: /* BCS Absolute. */
 			case 0x84: /* BCS Zero Matrix. */
-				if (opcode == BCS) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (cpu->c[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -720,34 +646,7 @@ void *run(void *args) {
 			case LLB: /* Logical shift Left accumulator by B. */
 			case 0x53: /* LSL Absolute. */
 			case 0x55: /* LSL Zero Matrix. */
-				if (opcode != LLB) {
-					if (opcode == LSL) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]++;
-					}
-					if (opcode == 0x53) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x55) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-				} else {
+				if (opcode == LLB) {
 					value = cpu->b[thread];
 				}
 				sum = (value < 64) ? cpu->a[thread] << value : 0;
@@ -767,69 +666,33 @@ void *run(void *args) {
 			case STY: /* STY Absolute. */
 			case STX: /* STX Absolute. */
 			case STB: /* STB Absolute. */
-			case 0x7B: /* STA Zero Matrix. */
-			case 0x7D: /* STY Zero Matrix. */
-			case 0x7E: /* STX Zero Matrix. */
-			case 0x7F: /* STB Zero Matrix. */
-			case 0x8B: /* STA Zero Matrix, Indexed with X. */
-			case 0x8D: /* STY Zero Matrix, Indexed with X. */
-			case 0x8F: /* STA Zero Matrix, Indexed with X. */
-			case 0x9B: /* STA Zero Matrix, Indexed with Y. */
-			case 0x9E: /* STX Zero Matrix, Indexed with Y. */
-			case 0x9F: /* STA Zero Matrix, Indexed with Y. */
-			case 0xAB: /* STA Indirect. */
-			case 0xAD: /* STY Indirect. */
-			case 0xAE: /* STX Indirect. */
-			case 0xAF: /* STB Indirect. */
-			case 0xBB: /* STA Indexed Indirect. */
-			case 0xBD: /* STY Indexed Indirect. */
-			case 0xBF: /* STB Indexed Indirect. */
-			case 0xCB: /* STA Indirect Indexed. */
-			case 0xCE: /* STX Indirect Indexed. */
-			case 0xCF: /* STB Indirect Indexed. */
-				if (opcode == STA || opcode == STY || opcode == STX || opcode == STB) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					if (opcode == 0xAB || opcode == 0xAD || opcode == 0xAE || opcode == 0xAF || opcode == 0xBB ||
-					    opcode == 0xBD || opcode == 0xBF || opcode == 0xCB || opcode == 0xCE || opcode == 0xCF) {
-							address =	(uint64_t)addr[address]
-									| (uint64_t)addr[address+1] << 8
-									| (uint64_t)addr[address+2] << 16
-									| (uint64_t)addr[address+3] << 24
-									| (uint64_t)addr[address+4] << 32
-									| (uint64_t)addr[address+5] << 40
-									| (uint64_t)addr[address+6] << 48
-									| (uint64_t)addr[address+7] << 56;
-						}
-					if (opcode == 0x8B || opcode == 0x8D || opcode == 0x8F ||
-					    opcode == 0xBB || opcode == 0xBD || opcode == 0xBF)
-						address += cpu->x[thread];
-					if (opcode == 0x9B || opcode == 0x9E || opcode == 0x9F ||
-					    opcode == 0xCB || opcode == 0xCE || opcode == 0xCF)
-						address += cpu->y[thread];
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
-				if (opcode == STA || opcode == 0x7B || opcode == 0x8B || opcode == 0x9B)
+			case 0x49: /* STA Zero Matrix. */
+			case 0x4A: /* STY Zero Matrix. */
+			case 0x4B: /* STX Zero Matrix. */
+			case 0x4E: /* STB Zero Matrix. */
+			case 0x69: /* STA Zero Matrix, Indexed with X. */
+			case 0x6A: /* STY Zero Matrix, Indexed with X. */
+			case 0x6B: /* STX Zero Matrix, Indexed with Y. */
+			case 0x6E: /* STB Zero Matrix, Indexed with X. */
+			case 0x89: /* STA Zero Matrix, Indexed with Y. */
+			case 0x8A: /* STY Indirect. */
+			case 0x8B: /* STX Indirect. */
+			case 0x8E: /* STB Zero Matrix, Indexed with Y. */
+			case 0xA9: /* STA Indirect. */
+			case 0xAA: /* STY Indexed Indirect. */
+			case 0xAB: /* STX Indirect Indexed. */
+			case 0xAE: /* STB Indirect. */
+			case 0xC9: /* STA Indexed Indirect. */
+			case 0xCE: /* STB Indexed Indirect. */
+			case 0xE9: /* STA Indirect Indexed. */
+			case 0xEE: /* STB Indirect Indexed. */
+				if (opcode == STA || opcode == 0x49 || opcode == 0x69 || opcode == 0x89 || opcode == 0xA9 || opcode == 0xC9 || opcode == 0xE9)
 					value = cpu->a[thread];
-				if (opcode == STY || opcode == 0x7D || opcode == 0x8D)
+				if (opcode == STY || opcode == 0x4A || opcode == 0x6A || opcode == 0x8A || opcode == 0xAA)
 					value = cpu->y[thread];
-				if (opcode == STX || opcode == 0x7E || opcode == 0x9E)
+				if (opcode == STY || opcode == 0x4B || opcode == 0x6B || opcode == 0x8B || opcode == 0xAB)
 					value = cpu->x[thread];
-				if (opcode == STB || opcode == 0x7F || opcode == 0x8F || opcode == 0x9F)
+				if (opcode == STB || opcode == 0x4E || opcode == 0x6E || opcode == 0x8E || opcode == 0xAE || opcode == 0xCE || opcode == 0xEE)
 					value = cpu->b[thread];
 				addr[address] = value & 0xFF;
 				#if IO
@@ -923,6 +786,7 @@ void *run(void *args) {
 					#endif
 				}
 				#else
+				#if !bench
 				if (address == TX_ADDR) {
 					if (esc) {
 						switch(addr[address]) {
@@ -955,7 +819,8 @@ void *run(void *args) {
 									x = 0;
 								else
 									x = ((bcd[1]*10) + bcd[0]);
-								mvwprintw(scr, getmaxy(scr)-25, 0, "x: %i, y: %i  ", x, y);
+								mvwprintw(scr, 30, 0, "x: %i, y: %i  ", x, y);
+								wrefresh(scr);
 								idx = 3;
 								bcd[0] = 0;
 								bcd[1] = 0;
@@ -997,6 +862,7 @@ void *run(void *args) {
 					}
 				}
 				#endif
+				#endif
 				if (regsize >= 2)
 					addr[address+1] = value >> 8;
 				if (regsize >= 4) {
@@ -1012,25 +878,6 @@ void *run(void *args) {
 				break;
 			case BCC: /* BCC Absolute. */
 			case 0x94: /* BCC Zero Matrix. */
-				if (opcode == BCC) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (!cpu->c[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -1038,46 +885,26 @@ void *run(void *args) {
 			case LRB: /* Logical shift Right accumulator by B. */
 			case 0x63: /* LSR Absolute. */
 			case 0x65: /* LSR Zero Matrix. */
+				if (opcode == LRB) {
+					value = cpu->b[thread];
+				}
+				sum = (value < 64) ? cpu->a[thread] >> value : 0;
+				cpu->z[thread] = (sum == 0);
+				cpu->n[thread] = (sum >> 63);
+				cpu->c[thread] = cpu->a[thread] & 1;
+				cpu->a[thread] = sum;
+				(cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread));
+				(cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread));
+				(cpu->c[thread]) ? (cpu->ps |= (C << 8*thread)) : (cpu->ps &= ~(C << 8*thread));
+				break;
 			case ASR: /* ASR Immediate. */
 			case ARB: /* Arithmetic shift Right accumulator by B. */
 			case 0xE3: /* ASR Absolute. */
 			case 0xE5: /* ASR Zero Matrix. */
-				if (opcode != LRB || opcode != ARB) {
-					if (opcode == LSR || opcode == ASR) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]++;
-					}
-					if (opcode == 0x63 || opcode == 0xE3) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x65 || opcode == 0xE5) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-				} else {
+				if (opcode == ARB)
 					value = cpu->b[thread];
-				}
-				if (opcode == ASR || opcode == ARB || opcode == 0xE3 || opcode == 0xE5) {
-					sign = cpu->a[thread] & 0x8000000000000000;
-					sum = (value < 64) ? (cpu->a[thread] >> value) | sign : 0;
-				}
-				if (opcode == LSR || opcode == LRB || opcode == 0x63 || opcode == 0x65) {
-					sum = (value < 64) ? cpu->a[thread] >> value : 0;
-				}
+				sign = cpu->a[thread] & 0x8000000000000000;
+				sum = (value < 64) ? (cpu->a[thread] >> value) | sign : 0;
 				cpu->z[thread] = (sum == 0);
 				cpu->n[thread] = (sum >> 63);
 				cpu->c[thread] = cpu->a[thread] & 1;
@@ -1090,73 +917,34 @@ void *run(void *args) {
 				cpu->c[thread] = 0;
 				(cpu->ps &= ~(C << 8*thread));
 				break;
-			case 0x56: /* LDB Absolute. */
-			case 0x59: /* LDA Absolute. */
-			case 0x5A: /* LDY Absolute. */
-			case 0x5C: /* LDX Absolute. */
 			case LDB: /* LDB Immediate. */
 			case LDA: /* LDA Immediate. */
 			case LDY: /* LDY Immediate. */
 			case LDX: /* LDX Immediate. */
-			case 0x76: /* LDB Zero Matrix. */
-			case 0x79: /* LDA Zero Matrix. */
-			case 0x7A: /* LDY Zero Matrix. */
-			case 0x7C: /* LDX Zero Matrix. */
-			case 0x86: /* LDB Zero Matrix, Indexed with X. */
-			case 0x89: /* LDA Zero Matrix, Indexed with X. */
-			case 0x8A: /* LDY Zero Matrix, Indexed with X. */
-			case 0x96: /* LDB Zero Matrix, Indexed with Y. */
-			case 0x99: /* LDA Zero Matrix, Indexed with Y. */
-			case 0x9C: /* LDX Zero Matrix, Indexed with Y. */
-			case 0xA6: /* LDB Indirect. */
-			case 0xA9: /* LDA Indirect. */
-			case 0xAA: /* LDY Indirect. */
-			case 0xAC: /* LDX Indirect. */
-			case 0xB6: /* LDB Indexed Indirect. */
+			case 0x1E: /* LDB Absolute. */
+			case 0x19: /* LDA Absolute. */
+			case 0x1A: /* LDY Absolute. */
+			case 0x1B: /* LDX Absolute. */
+			case 0x3E: /* LDB Zero Matrix. */
+			case 0x39: /* LDA Zero Matrix. */
+			case 0x3A: /* LDY Zero Matrix. */
+			case 0x3B: /* LDX Zero Matrix. */
+			case 0x5E: /* LDB Zero Matrix, Indexed with X. */
+			case 0x59: /* LDA Zero Matrix, Indexed with X. */
+			case 0x5A: /* LDY Zero Matrix, Indexed with X. */
+			case 0x5B: /* LDX Zero Matrix, Indexed with Y. */
+			case 0x7E: /* LDB Zero Matrix, Indexed with Y. */
+			case 0x79: /* LDA Zero Matrix, Indexed with Y. */
+			case 0x7A: /* LDY Indirect. */
+			case 0x7B: /* LDX Indirect. */
+			case 0x9E: /* LDB Indirect. */
+			case 0x99: /* LDA Indirect. */
+			case 0x9A: /* LDY Indexed Indirect. */
+			case 0x9B: /* LDX Indirect Indexed. */
+			case 0xBE: /* LDB Indexed Indirect. */
 			case 0xB9: /* LDA Indexed Indirect. */
-			case 0xBA: /* LDY Indexed Indirect. */
-			case 0xC6: /* LDB Indirect Indexed. */
-			case 0xC9: /* LDA Indirect Indexed. */
-			case 0xCC: /* LDX Indirect Indexed. */
-				if (opcode == LDB || opcode == LDA || opcode == LDY || opcode == LDX) {
-					address = cpu->pc[thread];
-					cpu->pc[thread]+=regsize;
-				} else if (opcode == 0x56 || opcode == 0x59 || opcode == 0x5A || opcode == 0x5C) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					if (opcode == 0xA6 || opcode == 0xA9 || opcode == 0xAA || opcode == 0xAC || opcode == 0xB6 ||
-					    opcode == 0xB9 || opcode == 0xBA || opcode == 0xC6 || opcode == 0xC9 || opcode == 0xCC) {
-							address =	(uint64_t)addr[address]
-									| (uint64_t)addr[address+1] << 8
-									| (uint64_t)addr[address+2] << 16
-									| (uint64_t)addr[address+3] << 24
-									| (uint64_t)addr[address+4] << 32
-									| (uint64_t)addr[address+5] << 40
-									| (uint64_t)addr[address+6] << 48
-									| (uint64_t)addr[address+7] << 56;
-						}
-					if (opcode == 0x86 || opcode == 0x89 || opcode == 0x8A ||
-					    opcode == 0xB6 || opcode == 0xB9 || opcode == 0xBA)
-						address += cpu->x[thread];
-					if (opcode == 0x96 || opcode == 0x99 || opcode == 0x9C ||
-					    opcode == 0xC6 || opcode == 0xC9 || opcode == 0xCC)
-						address += cpu->y[thread];
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
+			case 0xDE: /* LDB Indirect Indexed. */
+			case 0xD9: /* LDA Indirect Indexed. */
 				if (address == CTRL_ADDR) {
 					pthread_mutex_lock(&main_mutex);
 					pthread_cond_signal(&main_cond);
@@ -1180,13 +968,13 @@ void *run(void *args) {
 					value += (uint64_t)addr[address+6] << 48;
 					value += (uint64_t)addr[address+7] << 56;
 				}
-				if (opcode == LDB || opcode == 0x56 || opcode == 0x76 || opcode == 0x86 || opcode == 0x96)
+				if (opcode == LDB || opcode == 0x1E || opcode == 0x3E || opcode == 0x5E || opcode == 0x7E || opcode == 0x9E || opcode == 0xBE || opcode == 0xDE)
 					cpu->b[thread] = value;
-				if (opcode == LDA || opcode == 0x59 || opcode == 0x79 || opcode == 0x89 || opcode == 0x99)
+				if (opcode == LDA || opcode == 0x19 || opcode == 0x39 || opcode == 0x59 || opcode == 0x79 || opcode == 0x99 || opcode == 0xB9 || opcode == 0xD9)
 					cpu->a[thread] = value;
-				if (opcode == LDY || opcode == 0x5A || opcode == 0x7A || opcode == 0x8A)
+				if (opcode == LDY || opcode == 0x1A || opcode == 0x3A || opcode == 0x5A || opcode == 0x7A || opcode == 0x9A)
 					cpu->y[thread] = value;
-				if (opcode == LDX || opcode == 0x5C || opcode == 0x7C || opcode == 0x9C)
+				if (opcode == LDX || opcode == 0x1B || opcode == 0x3B || opcode == 0x5B || opcode == 0x7B || opcode == 0x9B)
 					cpu->x[thread] = value;
 				cpu->z[thread] = (value == 0);
 				cpu->n[thread] = (value >> 63);
@@ -1195,25 +983,6 @@ void *run(void *args) {
 				break;
 			case BEQ: /* BEQ Absolute. */
 			case 0xA4: /* BEQ Zero Matrix. */
-				if (opcode == BEQ) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (cpu->z[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -1221,33 +990,7 @@ void *run(void *args) {
 			case RLB: /* Rotate Left accumulator by B. */
 			case 0x73: /* ROL Absolute. */
 			case 0x75: /* ROL Zero Matrix. */
-				if (opcode != RLB) {
-					if (opcode == ROL) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]++;
-					}
-					if (opcode == 0x73) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x75) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-				} else {
+				if (opcode == RLB) {
 					value = cpu->b[thread];
 				}
 				sum = cpu->a[thread] << value;
@@ -1266,25 +1009,6 @@ void *run(void *args) {
 				break;
 			case BNE: /* BNE Absolute. */
 			case 0xB4: /* BNE Zero Matrix. */
-				if (opcode == BNE) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (!cpu->z[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -1292,33 +1016,7 @@ void *run(void *args) {
 			case RRB: /* Rotate Right accumulator by B. */
 			case 0x83: /* ROR Absolute. */
 			case 0x85: /* ROR Zero Matrix. */
-				if (opcode != RRB) {
-					if (opcode == ROR) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]++;
-					}
-					if (opcode == 0x83) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x85) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-				} else {
+				if (opcode == RRB) {
 					value = cpu->b[thread];
 				}
 				sum = cpu->a[thread] >> value;
@@ -1337,25 +1035,6 @@ void *run(void *args) {
 				break;
 			case BVS: /* BVS Absolute. */
 			case 0xC4: /* BVS Zero Matrix. */
-				if (opcode == BVS) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (cpu->v[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -1363,46 +1042,7 @@ void *run(void *args) {
 			case MAB: /* Multiply Accumulator by B. */
 			case 0x93: /* MUL Absolute. */
 			case 0x95: /* MUL Zero Matrix. */
-				if (opcode != MAB) {
-					if (opcode == MUL) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0x93) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0x95) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-					if (regsize >= 2) {
-						value += (uint64_t)addr[address+1] << 8;
-					}
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+				if (opcode == MAB) {
 					value = cpu->b[thread];
 				}
 				sum = cpu->a[thread]*value+cpu->c[thread];
@@ -1422,25 +1062,6 @@ void *run(void *args) {
 				break;
 			case BVC: /* BVC Absolute. */
 			case 0xD4: /* BVC Zero Matrix. */
-				if (opcode == BVC) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				} else {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				if (!cpu->v[thread])
 					cpu->pc[thread] = address;
 				break;
@@ -1449,44 +1070,6 @@ void *run(void *args) {
 			case 0xA3: /* DIV Absolute. */
 			case 0xA5: /* DIV Zero Matrix. */
 				if (opcode != DAB) {
-					if (opcode == DIV) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					}
-					if (opcode == 0xA3) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					}
-					if (opcode == 0xA5) {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = addr[address];
-					if (regsize >= 2) {
-						value += (uint64_t)addr[address+1] << 8;
-					}
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
 					cpu->b[thread] = cpu->a[thread] % value;
 				} else {
 					value = cpu->b[thread];
@@ -1504,7 +1087,11 @@ void *run(void *args) {
 				(cpu->ps &= ~(V << 8*thread));
 				break;
 			case RTS: /* ReTurn from Subroutine. */
-				for (uint8_t i = 0; i < 32; i+=8) {
+				if (addrsize)
+					stksize = 32;
+				else
+					stksize = 8;
+				for (uint8_t i = 0; i < stksize; i+=8) {
 					cpu->sp[thread]++;
 					if (i)
 						cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
@@ -1517,93 +1104,46 @@ void *run(void *args) {
 			case CAB: /* Compare Accumulator, and B. */
 			case CPY: /* CPY Immediate. */
 			case CPX: /* CPX Immediate. */
-			case 0x2B: /* CPY Absolute. */
-			case 0x2D: /* CPX Absolute. */
+			case 0xCA: /* CPY Absolute. */
+			case 0xCB: /* CPX Absolute. */
 			case 0xB3: /* CMP Absolute. */
-			case 0xE6: /* CPB Absolute. */
-			case 0x3B: /* CPY Zero Matrix. */
-			case 0x3D: /* CPX Zero Matrix. */
+			case 0x36: /* CPB Absolute. */
+			case 0xDA: /* CPY Zero Matrix. */
+			case 0xDB: /* CPX Zero Matrix. */
 			case 0xB5: /* CMP Zero Matrix. */
-			case 0xF6: /* CPB Zero Matrix. */
-			case 0xE9: /* CMP Indirect. */
+			case 0x46: /* CPB Zero Matrix. */
+			case 0xF1: /* CMP Indirect. */
 			case 0xEA: /* CPY Indirect. */
-			case 0xEC: /* CPX Indirect. */
-			case 0xDF: /* CPB Indirect. */
-			case 0xEB: /* CMP Indexed Indirect. */
+			case 0xEB: /* CPX Indirect. */
+			case 0x56: /* CPB Indirect. */
+			case 0xF3: /* CMP Indexed Indirect. */
 			case 0xFA: /* CPY Indexed Indirect. */
-			case 0xEF: /* CPB Indexed Indirect. */
-			case 0xED: /* CMP Indirect Indexed. */
-			case 0xFC: /* CPX Indirect Indexed. */
-			case 0xFF: /* CPB Indirect Indexed. */
-				if (opcode != CAB) {
-					if (opcode == CMP || opcode == CPY || opcode == CPX || opcode == CPB) {
-						address = cpu->pc[thread];
-						cpu->pc[thread]+=regsize;
-					} else if (opcode == 0xB3 || opcode == 0x2B || opcode == 0x2D) {
-						address =	(uint64_t)addr[cpu->pc[thread]]
-								| (uint64_t)addr[cpu->pc[thread]+1] << 8
-								| (uint64_t)addr[cpu->pc[thread]+2] << 16
-								| (uint64_t)addr[cpu->pc[thread]+3] << 24
-								| (uint64_t)addr[cpu->pc[thread]+4] << 32
-								| (uint64_t)addr[cpu->pc[thread]+5] << 40
-								| (uint64_t)addr[cpu->pc[thread]+6] << 48
-								| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-						cpu->pc[thread]+=8;
-						iclk++;
-					} else {
-						address =	addr[cpu->pc[thread]]
-								| addr[cpu->pc[thread]+1] << 8
-								| addr[cpu->pc[thread]+2] << 16
-								| addr[cpu->pc[thread]+3] << 24;
-						if (opcode == 0xDF || opcode == 0xE9 || opcode == 0xEA || opcode == 0xEB || opcode == 0xEC ||
-						    opcode == 0xED || opcode == 0xEF || opcode == 0xFA || opcode == 0xFC || opcode == 0xFF) {
-							address =	(uint64_t)addr[address]
-									| (uint64_t)addr[address+1] << 8
-									| (uint64_t)addr[address+2] << 16
-									| (uint64_t)addr[address+3] << 24
-									| (uint64_t)addr[address+4] << 32
-									| (uint64_t)addr[address+5] << 40
-									| (uint64_t)addr[address+6] << 48
-									| (uint64_t)addr[address+7] << 56;
-							if (opcode == 0xEB || opcode == 0xEF || opcode == 0xFA)
-								address += cpu->x[thread];
-							if (opcode == 0xED || opcode == 0xFC || opcode == 0xFF)
-								address += cpu->y[thread];
-						}
-						cpu->pc[thread]+=4;
-						iclk++;
-					}
-					value = (uint64_t)addr[address];
-					if (regsize >= 2)
-						value += (uint64_t)addr[address+1] << 8;
-					if (regsize >= 4) {
-						value += (uint64_t)addr[address+2] << 16;
-						value += (uint64_t)addr[address+3] << 24;
-					}
-					if (regsize >= 8) {
-						value += (uint64_t)addr[address+4] << 32;
-						value += (uint64_t)addr[address+5] << 40;
-						value += (uint64_t)addr[address+6] << 48;
-						value += (uint64_t)addr[address+7] << 56;
-					}
-				} else {
+			case 0x66: /* CPB Indexed Indirect. */
+			case 0xF5: /* CMP Indirect Indexed. */
+			case 0xFB: /* CPX Indirect Indexed. */
+			case 0x76: /* CPB Indirect Indexed. */
+				if (opcode == CAB) {
 					value = cpu->b[thread];
 				}
-				if (opcode == CMP || opcode == CAB || opcode == 0xE5 || opcode == 0xF5)
-					sum = cpu->a[thread]-value;
-				if (opcode == CPY || opcode == 0xE2 || opcode == 0xF2)
-					sum = cpu->y[thread]-value;
-				if (opcode == CPX || opcode == 0xE4 || opcode == 0xF4)
-					sum = cpu->x[thread]-value;
+				if (opcode == CPB || opcode == 0x36 || opcode == 0x46 || opcode == 0x56 || opcode == 0x66 || opcode == 0x76)
+					reg = cpu->b[thread];
+				if (opcode == CMP || opcode == CAB || opcode == 0xB3 || opcode == 0xB5 || opcode == 0xF1 || opcode == 0xF3 || opcode == 0xF5)
+					reg = cpu->a[thread];
+				if (opcode == CPY || opcode == 0xCA || opcode == 0xDA || opcode == 0xEA || opcode == 0xFA)
+					reg = cpu->y[thread];
+				if (opcode == CPX || opcode == 0xCB || opcode == 0xDB || opcode == 0xEB || opcode == 0xFB)
+					reg = cpu->x[thread];
+				sum = reg-value;
 				cpu->n[thread] = (sum & 0x8000000000000000) ? 1 : 0;
+				cpu->v[thread] = ((reg^value) & 0x8000000000000000) && ((reg^sum) & 0x8000000000000000);
 				cpu->z[thread] = (sum == 0) ? 1 : 0;
 				cpu->c[thread] = (sum > value) ? 1 : 0;
-				(cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread));
 				(cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread));
+				(cpu->v[thread]) ? (cpu->ps |= (V << 8*thread)) : (cpu->ps &= ~(V << 8*thread));
+				(cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread));
 				(cpu->c[thread]) ? (cpu->ps |= (C << 8*thread)) : (cpu->ps &= ~(C << 8*thread));
 				break;
 			case ENT: /* ENd Thread. */
-				value = addr[address];
 				cpu->crt &= ~value;
 				for (uint8_t i = 0; i < 7; i++)
 					if ((value >> i) & 1)
@@ -1648,27 +1188,6 @@ void *run(void *args) {
 			case 0x14: /* JMP Indexed Indirect. */
 			case 0x24: /* JMP Indirect Indexed. */
 			case 0xD0: /* JMP Zero Matrix. */
-				address =	(uint32_t)addr[cpu->pc[thread]]
-						|(uint32_t)addr[cpu->pc[thread]+1] << 8
-						|(uint32_t)addr[cpu->pc[thread]+2] << 16
-						|(uint32_t)addr[cpu->pc[thread]+3] << 24;
-
-				if (opcode == 0x04 || opcode == 0x14 || opcode == 0x24) {
-					address =	(uint64_t)addr[address]
-							| (uint64_t)addr[address+1] << 8
-							| (uint64_t)addr[address+2] << 16
-							| (uint64_t)addr[address+3] << 24
-							| (uint64_t)addr[address+4] << 32
-							| (uint64_t)addr[address+5] << 40
-							| (uint64_t)addr[address+6] << 48
-							| (uint64_t)addr[address+7] << 56;
-					if (opcode == 0x14)
-						address += cpu->x[thread];
-					if (opcode == 0x24)
-						address += cpu->y[thread];
-				}
-				cpu->pc[thread]+=4;
-				iclk++;
 				cpu->pc[thread] = address;
 				break;
 
@@ -1697,16 +1216,11 @@ void *run(void *args) {
 				(cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread));
 				break;
 			case JSL: /* Jump to Subroutine Long. */
-				address =	(uint64_t)addr[cpu->pc[thread]]
-						| (uint64_t)addr[cpu->pc[thread]+1] << 8
-						| (uint64_t)addr[cpu->pc[thread]+2] << 16
-						| (uint64_t)addr[cpu->pc[thread]+3] << 24
-						| (uint64_t)addr[cpu->pc[thread]+4] << 32
-						| (uint64_t)addr[cpu->pc[thread]+5] << 40
-						| (uint64_t)addr[cpu->pc[thread]+6] << 48
-						| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-				cpu->pc[thread]+=8;
-				for (int8_t i = 56; i >= 0; i-=8) {
+				if (addrsize)
+					stksize = 56;
+				else
+					stksize = 8;
+				for (int8_t i = stksize; i >= 0; i-=8) {
 					if (i)
 						addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> i;
 					else
@@ -1717,63 +1231,25 @@ void *run(void *args) {
 				break;
 			case 0xC3: /* INC Absolute. */
 			case 0xC5: /* INC Zero Matrix. */
-				if (opcode == 0xC3) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				}
-				if (opcode == 0xC5) {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				addr[address]++;
 				break;
 			case NOP: /* No OPeration. */
 				break;
 			case RTL: /* ReTurn from subroutine Long. */
-				for (uint8_t i = 0; i < 64; i+=8) {
+				if (addrsize)
+					stksize = 64;
+				else
+					stksize = 16;
+				for (uint8_t i = 0; i < stksize; i+=8) {
 					cpu->sp[thread]++;
-					if (i < 56)
-						cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
-					else if (i == 56)
-						cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i + 1;
+					if (i)
+						cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
 					else
 						cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]];
 				}
 				break;
 			case 0xD3: /* DEC Absolute. */
 			case 0xD5: /* DEC Zero Matrix. */
-				if (opcode == 0xD3) {
-					address =	(uint64_t)addr[cpu->pc[thread]]
-							| (uint64_t)addr[cpu->pc[thread]+1] << 8
-							| (uint64_t)addr[cpu->pc[thread]+2] << 16
-							| (uint64_t)addr[cpu->pc[thread]+3] << 24
-							| (uint64_t)addr[cpu->pc[thread]+4] << 32
-							| (uint64_t)addr[cpu->pc[thread]+5] << 40
-							| (uint64_t)addr[cpu->pc[thread]+6] << 48
-							| (uint64_t)addr[cpu->pc[thread]+7] << 56;
-					cpu->pc[thread]+=8;
-					iclk++;
-				}
-				if (opcode == 0xD5) {
-					address =	addr[cpu->pc[thread]]
-							| addr[cpu->pc[thread]+1] << 8
-							| addr[cpu->pc[thread]+2] << 16
-							| addr[cpu->pc[thread]+3] << 24;
-					cpu->pc[thread]+=4;
-					iclk++;
-				}
 				addr[address]--;
 				break;
 			case BRK: /* BReaK. */
@@ -1810,18 +1286,17 @@ void *run(void *args) {
 				break;
 		}
 		ins++;
-		usleep(100000);
 	#if debug && !bench
 		#if keypoll
 		pthread_mutex_lock(&mutex);
 		#endif
-		mvwprintw(scr, getmaxy(scr)-lines, 0, "Operand: $%llx"
+		/*mvwprintw(scr, getmaxy(scr)-lines, 0, "Operand: $%llx"
 				", $%04llx: $%02x, $%04llx: $%02x"
 				", $1000: $%02x, $1001: $%02x    "
 				, value
 				, RX_ADDR, addr[RX_ADDR], TX_ADDR, addr[TX_ADDR]
-				, addr[0x1000], addr[0x1001]);
-		mvwprintw(scr, (24*thread)+1, 0, "Instructions executed: %llu, Clock cycles: %llu\r", ins, iclk);
+				, addr[0x1000], addr[0x1001]);*/
+		mvwprintw(scr, (6*thread)+1, 0, "Instructions executed: %llu, Clock cycles: %llu\r", ins, iclk);
 		wrefresh(scr);
 		#if keypoll
 		pthread_mutex_unlock(&mutex);
@@ -1830,12 +1305,12 @@ void *run(void *args) {
 	#if bench
 		if (ins >= BENCH_INST) {
 			end = 1;
-			pthread_mutex_lock(&mutex);
+			pthread_mutex_lock(&main_mutex);
 			threads_done++;
 			inst[thread] = ins;
 			clk[thread] = iclk;
 			pthread_cond_signal(&main_cond);
-			pthread_mutex_unlock(&mutex);
+			pthread_mutex_unlock(&main_mutex);
 			gettimeofday(&en[thread], 0);
 		}
 	#endif
@@ -1861,6 +1336,7 @@ int main(int argc, char **argv) {
 	sprintf(tmp, "\033[2J\033[H");
 	fwrite(tmp, sizeof(char), strlen(tmp), stdout);
 	fflush(stdout);
+#if !bench
 	if(!scr)
 		scr = initscr();
 	nodelay(stdscr, 0);
@@ -1876,11 +1352,13 @@ int main(int argc, char **argv) {
 	init_pair(1, COLOR_WHITE, -1);
 	attron(COLOR_PAIR(1) | A_BOLD);
 	wmove(scr, 0, 0);
+#endif
 	for (int i = 0; i < THREADS; i++) {
 		thr[i].sx.sp[i] = 0xFFFF;
 		thr[i].sx.stk_st[i] = i+1;
 		if (i) {
 			thr[i].sx.a[i] = 0;
+			thr[i].sx.b[i] = 0;
 			thr[i].sx.x[i] = 0;
 			thr[i].sx.y[i] = 0;
 			thr[i].sx.pc[i] = (uint64_t)addr[0xFF50+(8*(i-1))]
@@ -1893,6 +1371,7 @@ int main(int argc, char **argv) {
 					| (uint64_t)addr[0xFF57+(8*(i-1))] << 56;
 		} else {
 			thr[i].sx.a[i] = 0;
+			thr[i].sx.b[i] = 0;
 			thr[i].sx.x[i] = 0;
 			thr[i].sx.y[i] = 0;
 			thr[i].sx.pc[i] = (uint64_t)addr[0xFFC0]
@@ -1916,10 +1395,12 @@ int main(int argc, char **argv) {
 		assert(!result);
 	}
 	int c = 0;
+#if !bench
 	werase(scr);
+#endif
 	while (threads_done < THREADS) {
-		int x, y, i = 0;
 		#if !bench
+		int x, y, i = 0;
 		if ((c != EOF && c !=-1)) {
 			pthread_mutex_lock(&main_mutex);
 			curs_set(0);
@@ -1945,6 +1426,7 @@ int main(int argc, char **argv) {
 			default:
 				addr[RX_ADDR] = (uint8_t)c;
 				addr[CTRL_ADDR] = 1;
+				kbd_rdy = 1;
 				#if !keypoll
 				pthread_mutex_lock(&mutex);
 				pthread_cond_signal(&cond);
@@ -1963,10 +1445,6 @@ int main(int argc, char **argv) {
 	}
 #if bench
 	if (threads_done == THREADS) {
-		#if en_nc
-		scr = NULL;
-		endwin();
-		#endif
 		double tm_sec, tm_usec, tm[THREADS], ttm;
 		double clkspd;
 		double mhz;