#include "opcode.h"
#include <assert.h>
#include <ctype.h>
#include <string.h>
#include <pthread.h>
#define bench 0
#define debug 1
#define IO 0
#define keypoll 0
#if bench
#include <sys/time.h>
#else
#include <curses.h>
#endif

#define THREADS	1
#define BENCH_INST 100000000 << THREADS-1
#define CTRL_ADDR 0xC000
#define TX_ADDR 0xC001
#define RX_ADDR 0xC002
#define STEP_ADDR 0xC010
#define CURSES_BACKSPACE 0x7F

#define setflag(flag, bit) ((flag)) ? (cpu->ps |= (bit << (thread << 3))) : (cpu->ps &= ~(bit << (thread << 3)))
#define getflag(bit) (cpu->ps & (bit << (thread << 3)))

uint64_t clk[THREADS];	/* Per Thread Clock cycles. */
uint64_t tclk;		/* Total Clock cycles. */
uint64_t inst[THREADS];
uint64_t inss;
uint8_t threads_done = 0;
uint8_t kbd_rdy = 0;
uint8_t kbd_ln = 0;
uint8_t wai = 0;
uint8_t step = 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;
pthread_cond_t main_cond = PTHREAD_COND_INITIALIZER;
struct suxthr {
	struct sux sx;
	uint8_t th;
};
#if bench
double ipc;
struct timeval str[THREADS], en[THREADS];
#endif

void *run(void *args) {
	struct suxthr *thr = (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;
	uint8_t addrsize;
	uint8_t rs;
	uint8_t regsize;
	uint8_t tmp;
	uint8_t tmp2;
	char *s = malloc(2048);
#if !bench
	uint8_t lines = (6*thread)+2;
	uint8_t bcd[4];
	uint8_t idx = 3, iscol = 0;
	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
#if debug && !bench
	uint8_t scr_row = 0xFF, scr_col = 0xFF;
	uint8_t updt = 0;
	#if keypoll
	pthread_mutex_lock(&mutex);
	#endif
	werase(scr);
	#if keypoll
	pthread_mutex_unlock(&mutex);
	#endif
#endif
	while (!end) {
		address = 0;
		if (wai) {
			for (int8_t i = 56; i >= 0; i-=8) {
				if (i)
					addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread]-1 >> i;
				else
					addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread]-1 & 0xFF;
				cpu->sp[thread]--;
			}
			addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->ps >> 8*thread;
			cpu->sp[thread]--;
			setflag(1, I);
			cpu->pc[thread] = (uint64_t)addr[0xFFA0]
					| (uint64_t)addr[0xFFA1] << 8
					| (uint64_t)addr[0xFFA2] << 16
					| (uint64_t)addr[0xFFA3] << 24
					| (uint64_t)addr[0xFFA4] << 32
					| (uint64_t)addr[0xFFA5] << 40
					| (uint64_t)addr[0xFFA6] << 48
					| (uint64_t)addr[0xFFA7] << 56;
			wai = 0;
			kbd_rdy &= (uint8_t)~(1 << thread);
		}
		prefix = addr[cpu->pc[thread]];
		if ((prefix & 0x03) == 0x03)
			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
		wmove(scr, lines, 0);
		wclrtoeol(scr);
		wprintw(scr,
			"pc: $%08llX"
			", a: $%016llX"
			", b: $%016llX"
			", x: $%016llX"
			", y: $%016llX"
			, cpu->pc[thread]
			, cpu->a[thread]
			, cpu->b[thread]
			, cpu->x[thread]
			, cpu->y[thread]);
		wprintw(scr,
			", sp: $%04X"
			", ps: $%04X"
			", prefix: $%02x"
			", opcode: $%02x"
			", inst: "
			, cpu->sp[thread]
			, cpu->ps
			, prefix
			, opcode);
		#if keypoll
		pthread_mutex_unlock(&mutex);
		#endif
	#endif

		addrsize = (prefix & 0x0C) >> 2;
		rs = (prefix & 0x30) >> 4;
		if (rs)
			regsize = (1 << rs);
		else
			regsize = 1;
		address = cpu->pc[thread];
		cpu->pc[thread]++;
		iclk++;
		switch (optype[opcode]) {
			case IMPL:
				break;
			case IMM:
				switch (opcode) {
					case TXS:
						break;

					case PHB:
					case PHP:
					case PHA:
					case PHY:
					case PHX:
					case PLB:
					case PLP:
					case PLA:
					case PLY:
					case PLX:
					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]];
				switch (addrsize) {
					case 2:
						address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;
						address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;
						cpu->pc[thread]+=2;
					case 3:
						address |= addr[cpu->pc[thread]+3] << 24;
						cpu->pc[thread]+=1;
					case 1:
						address |= addr[cpu->pc[thread]+2] << 16;
						address |= addr[cpu->pc[thread]+1] << 8;
						cpu->pc[thread]+=2;
					case 0:
						cpu->pc[thread]+=1;
				}
				tmpaddr = address;
				switch (optype[opcode]) {
					case ZMX:
						address += cpu->x[thread];
						iclk++;
						break;
					case ZMY:
						address += cpu->y[thread];
						iclk++;
						break;
				}
				iclk++;
				break;
			case IND:
			case INDX:
			case INDY:
				address = addr[cpu->pc[thread]];
				switch (addrsize) {
					case 2:
						address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;
						address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;
						cpu->pc[thread]+=2;
					case 3:
						address |= addr[cpu->pc[thread]+3] << 24;
						cpu->pc[thread]+=1;
					case 1:
						address |= addr[cpu->pc[thread]+2] << 16;
						address |= addr[cpu->pc[thread]+1] << 8;
						cpu->pc[thread]+=2;
					case 0:
						cpu->pc[thread]+=1;
				}
				iclk++;
				tmpaddr = address;
				if (optype[opcode] == INDX) {
					address += cpu->x[thread];
					iclk++;
				}
				value =	addr[address];
				value |= addr[address+1] << 8;
				value |= addr[address+2] << 16;
				value |= addr[address+3] << 24;
				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;
				iclk++;
				if (optype[opcode] == INDY) {
					value += cpu->y[thread];
					iclk++;
				}
				address = value;
				value = 0;
				iclk++;
				break;
			case ABS:
				address = addr[cpu->pc[thread]];
				switch (addrsize) {
					case 3:
						address |= (uint64_t)addr[cpu->pc[thread]+7] << 56;
						cpu->pc[thread]+=1;
					case 2:
						address |= (uint64_t)addr[cpu->pc[thread]+6] << 48;
						address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;
						cpu->pc[thread]+=2;
						iclk++;
					case 1:
						address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;
						address |= addr[cpu->pc[thread]+3] << 24;
						address |= addr[cpu->pc[thread]+2] << 16;
						cpu->pc[thread]+=3;
					case 0:
						address |= addr[cpu->pc[thread]+1] << 8;
						cpu->pc[thread]+=2;
				}
				break;

		}
		value = addr[address];
		switch (regsize) {
			case 8:
				value |= (uint64_t)addr[address+7] << 56;
				value |= (uint64_t)addr[address+6] << 48;
				value |= (uint64_t)addr[address+5] << 40;
				value |= (uint64_t)addr[address+4] << 32;
			case 4:
				value |= addr[address+3] << 24;
				value |= addr[address+2] << 16;
			case 2:
				value |= addr[address+1] << 8;
		}
	#if debug && !bench
		#if keypoll
		pthread_mutex_lock(&mutex);
		#endif
		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';
			else if (regsize == 4)
				postfix[1] = 'D';
			else if (regsize == 8)
				postfix[1] = 'Q';
			postfix[2] = '\0';
		}
		switch (optype[opcode]) {
			case IMPL: wprintw(scr, "%s\r" , opname[opcode]); break;
			case IMM:
				switch(regsize) {
					case 1: wprintw(scr, "%s #$%02X\r" , op, value); break;
					case 2: wprintw(scr, "%s%s #$%04X\r" , op, postfix, value); break;
					case 4: wprintw(scr, "%s%s #$%08X\r" , op, postfix, value); break;
					case 8: wprintw(scr, "%s%s #$%016llX\r" , op, postfix, value); break;
				}
				break;
			case ZM:
			case ZMX:
			case ZMY:
				if (optype[opcode] == ZMX)
					tmpaddr = address - cpu->x[thread];
				else if (optype[opcode] == ZMY)
					tmpaddr = address - cpu->y[thread];
				switch (addrsize) {
					case 3: wprintw(scr, "%s%s $%08X%s\r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); break;
					case 2: wprintw(scr, "%s%s $%014llX%s\r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); break;
					case 1: wprintw(scr, "%s%s $%06X%s\r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); break;
					case 0: wprintw(scr, "%s%s $%02X%s\r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); break;
				}
				break;
			case IND:
			case INDX:
			case INDY:
				switch (addrsize) {
					case 3: wprintw(scr, "%s%s ($%08X%s\r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); break;
					case 2: wprintw(scr, "%s%s ($%012llX%s\r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); break;
					case 1: wprintw(scr, "%s%s ($%06X%s\r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); break;
					case 0: wprintw(scr, "%s%s ($%02X%s\r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); break;
				}
				break;
			case ABS:
				tmpaddr = address;
				switch (addrsize) {
					case 3: wprintw(scr, "%s%s $%016llX\r" , op, postfix, tmpaddr);	break;
					case 2: wprintw(scr, "%s%s $%014llX\r" , op, postfix, tmpaddr);	break;
					case 1: wprintw(scr, "%s%s $%010llX\r" , op, postfix, tmpaddr);	break;
					case 0: wprintw(scr, "%s%s $%04X\r" , op, postfix, tmpaddr   );	break;
				}
				break;
		}
		mvwprintw(scr, 27, 0, "TX_ADDR: $%02X, RX_ADDR: $%02X\r", addr[TX_ADDR], addr[RX_ADDR]);
		mvwprintw(scr, 28, 0, "scr_ptr3: %04X\r", (addr[0x5C] << 8) | addr[0x5B]);
		mvwprintw(scr, 29, 0, "address: $%016llx, scr_row: %02u, scr_col: %02u, scr_str: %02u, scr_end: %02u\r", address, addr[0], addr[1], addr[0x28], addr[0x29]);
		mvwprintw(scr, 32, 0, "bitabl: %02x %02x %02x %02x %02x %02x %02x %02x "
				      "%02x %02x %02x %02x %02x %02x %02x %02x\r"
				       , addr[0x18], addr[0x19], addr[0x1A], addr[0x1B], addr[0x1C], addr[0x1D], addr[0x1E], addr[0x1F]
				       , addr[0x20], addr[0x21], addr[0x22], addr[0x23], addr[0x24], addr[0x25], addr[0x26], addr[0x27]);
		uint8_t ln = 33;
		uint16_t line_idx = 0;
		uint16_t tmpad = 0x2000;
		int row, col;
		uint8_t iscursor = 0;
		mvwprintw(scr, ln++, 0, "buffer:\r");
		if (updt) {
			scr_row = addr[0];
			scr_col = addr[1];
			wmove(scr, ln++, 0);
			for (uint8_t i = 0; i < 10; i++) {
				line_idx = (i << 6) + (i << 4);
				for (uint8_t j = 0; j < 0x50; j++) {
					wprintw(scr, "%02X", addr[tmpad+j+line_idx]);
						if ((addr[0]+addr[0x28]) == i && addr[1] == j) {
							iscursor=1;
							getyx(scr,row, col);
							wmove(scr, ln++, 0);
							wclrtoeol(scr);
							wmove(scr, row+1, col-2);
							wprintw(scr, "/\\\r");
							wmove(scr, row, col);
						}
				}
				wprintw(scr, ", i: %02X\r", i);
				if (!iscursor) {
					wmove(scr, ln, 0);
					wclrtoeol(scr);
				}
				iscursor = 0;
				wmove(scr, ln++, 0);
			}
			updt = 0;
		}
		/*tmpad = 0x4000;
		line_idx = 0;
		mvwprintw(scr, ln++, 0, "cmd_buf:\r");
		for (uint8_t i = 0; i < 20; i++) {
			wmove(scr, ln);
			line_idx = (i << 4)+(i << 6);
			for (uint8_t j = 0; j < 0x10; j++) {
				wprintw(scr, "%02X ", addr[tmpad+j+line_idx]);
			}
			wprintw(scr, ", i: %02X\r", i);
			ln++;
		}*/
		#if keypoll
		pthread_mutex_unlock(&mutex);
		#endif
		lines+=1;
	#endif
		switch(opcode) {
			case CPS: /* Clear Processor Status. */
				cpu->ps &= 0;
				break;
			case ADC:  /* ADC Immediate. */
			case AAB: /* Add Accumulator with carry by B register. */
			case ADC_AB: /* ADC Absolute. */
			case ADC_Z: /* ADC Zero Matrix. */
				if (opcode == AAB)
					value = cpu->b[thread];
				sum = cpu->a[thread]+value+getflag(C);
				cpu->a[thread] = sum;
				setflag(sum == 0, Z);
				setflag((sum >> 63), N);
				setflag(((cpu->a[thread]^value) & 0x8000000000000000) && ((cpu->a[thread]^sum) & 0x8000000000000000), V);
				setflag((sum < value), C);
				break;
			case PHB: /* PusH B register to stack. */
			case PHP: /* PusH Processor status to stack. */
			case PHA: /* PusH Accumulator to stack. */
			case PHY: /* PusH Y register to stack. */
			case PHX: /* PusH X register to stack. */
				tmp = value;
				switch (opcode) {
					case PHA: reg = cpu->a[thread]; break;
					case PHB: reg = cpu->b[thread]; break;
					case PHX: reg = cpu->x[thread]; break;
					case PHY: reg = cpu->y[thread]; break;
					case PHP: reg = cpu->ps;	break;
				}
				if (tmp > 7)
					tmp = 7;
				switch (tmp) {
					case 7:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (7<<3);
					case 6:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (6<<3);
					case 5:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (5<<3);
					case 4:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (4<<3);
					case 3:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (3<<3);
					case 2:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (2<<3);
					case 1:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg >> (1<<3);
					case 0:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = reg & 0xFF;
				}
				break;
			case TAY: /* Transfer Accumulator to Y. */
			case TAX: /* Transfer Accumulator to Y. */
			case TYX: /* Transfer Y to X. */
			case TYA: /* Transfer Y to Accumulator. */
			case TXA: /* Transfer X to Accumulator. */
			case TXY: /* Transfer X to Y. */
			case TAB: /* Transfer Accumulator to B. */
			case TSX: /* Transfer Stack pointer to X. */
			case TBA: /* Transfer B to Accumulator. */
			case TXS: /* Transfer X to Stack pointer. */
				switch (opcode) {
					case TAY: cpu->y[thread] = cpu->a[thread]; break;
                                        case TAX: cpu->x[thread] = cpu->a[thread]; break;
                                        case TYX: cpu->x[thread] = cpu->y[thread]; break;
                                        case TYA: cpu->a[thread] = cpu->y[thread]; break;
                                        case TXA: cpu->a[thread] = cpu->x[thread]; break;
					case TXY: cpu->y[thread] = cpu->x[thread]; break;
                                        case TAB: cpu->b[thread] = cpu->a[thread];
						setflag(cpu->b[thread] == 0, Z);
						setflag(cpu->b[thread] >> 63, N);
						break;
                                        case TSX: cpu->x[thread] = cpu->sp[thread] & 0xFFFF;
						cpu->x[thread] = cpu->stk_st[thread] << 16;
						break;
                                        case TBA: cpu->a[thread] = cpu->b[thread]; break;
                                        case TXS: cpu->sp[thread] = cpu->x[thread];
						if (prefix == 0x13 && (value == thread+1 || value > 8)) {
							cpu->stk_st[thread] = value & 0xFF;
							cpu->stk_st[thread] += value << 16;
							cpu->pc[thread]+=2;
						}
						break;
				}
				switch (opcode) {
					case TYA:
					case TXA:
					case TBA:
						setflag(cpu->a[thread] == 0, Z);
						setflag(cpu->a[thread] >> 63, N);
						break;
					case TAY:
					case TXY:
						setflag(cpu->y[thread] == 0, Z);
						setflag(cpu->y[thread] >> 63, N);
						break;
					case TAX:
					case TYX:
						setflag(cpu->x[thread] == 0, Z);
						setflag(cpu->x[thread] >> 63, N);
						break;
				}
				break;
			case JMP: /* JMP Absolute. */
			case JMP_Z: /* JMP Zero Matrix. */
			case JMP_IN: /* JMP Indirect. */
				cpu->pc[thread] = address;
				break;
			case SBC: /* SBC Immediate. */
			case SAB: /* Subtract Accumulator with carry by B register. */
			case SBC_AB: /* SBC Absolute. */
			case SBC_Z: /* SBC Zero Matrix. */
				if (opcode == SAB) {
					value = cpu->b[thread];
				}
				sum = cpu->a[thread]-value-!getflag(C);
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(((cpu->a[thread]^value) & 0x8000000000000000) && ((cpu->a[thread]^sum) & 0x8000000000000000), V);
				setflag((sum > value), C);
				cpu->a[thread] = sum;
				break;
			case PLB: /* PuLl B register from stack. */
			case PLP: /* PuLl Processor status from stack. */
			case PLA: /* PuLl Accumulator from stack. */
			case PLY: /* PuLl Y register from stack. */
			case PLX: /* PuLl X register from stack. */
				tmp = value;
				switch (opcode) {
					case PLA: reg = cpu->a[thread]; break;
					case PLB: reg = cpu->b[thread]; break;
					case PLX: reg = cpu->x[thread]; break;
					case PLY: reg = cpu->y[thread]; break;
					case PLP: reg = cpu->ps;	break;
				}
				if (tmp > 7)
					tmp = 7;
				tmp2 = 0;
				cpu->sp[thread]++;reg = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;tmp--;
				switch (tmp) {
					case 6:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 5:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 4:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 3:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 2:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 1:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 0:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
				}
				if (opcode == PLB) {
					cpu->b[thread] = reg;
				} else if (opcode == PLP) {
					cpu->ps = reg;
				} else if (opcode == PLA) {
					cpu->a[thread] = reg;
				} else if (opcode == PLY) {
					cpu->y[thread] = reg;
				} else if (opcode == PLX) {
					cpu->x[thread] = reg;
				}
				break;
			case JSR_IN: /* JSR Indirect. */
			case JSR: /* Jump to SubRoutine. */
				switch (addrsize) {
					case 3: stksize = 3; break;
					case 2: stksize = 5; break;
					case 1: stksize = 2; break;
					case 0: stksize = 0; break;
				}
				switch (stksize) {
					case 7:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (7<<3);
					case 6:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (6<<3);
					case 5:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (5<<3);
					case 4:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (4<<3);
					case 3:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (3<<3);
					case 2:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (2<<3);
					case 1:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] >> (1<<3);
					case 0:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]--] = (uint64_t)cpu->pc[thread] & 0xFF;
				}
				cpu->pc[thread] = address;
				break;
			case AND: /* AND Immediate. */
			case ABA: /* bitwise And with Accumulator, and B register. */
			case AND_AB: /* AND Absolute. */
			case AND_Z: /* AND Zero Matrix. */
				if (opcode == ABA) {
					value = cpu->b[thread];
				}
				cpu->a[thread] &= value;
				setflag(value == 0, Z);
				setflag(value >> 63, N);
				break;
			case STT: /* STart Thread. */
				cpu->crt |= value;
				for (uint8_t i = 0; i < 7; i++) {
					if ((value >> i) & 1) {
						address = (uint64_t)addr[tv+(i<<3)]
								| (uint64_t)addr[tv+1+(i<<3)] << 8
								| (uint64_t)addr[tv+2+(i<<3)] << 16
								| (uint64_t)addr[tv+3+(i<<3)] << 24
								| (uint64_t)addr[tv+4+(i<<3)] << 32
								| (uint64_t)addr[tv+5+(i<<3)] << 40
								| (uint64_t)addr[tv+6+(i<<3)] << 48
								| (uint64_t)addr[tv+7+(i<<3)] << 56;
						cpu->pc[i+1] = address;
					}
				}
				break;
			case BPO: /* BPO Absolute. */
			case BPO_Z: /* BPO Zero Matrix. */
				if (!getflag(N))
					cpu->pc[thread] = address;
				break;
			case ORA: /* ORA Immediate. */
			case OAB: /* bitwise Or with Accumulator, and B register. */
			case ORA_AB: /* ORA Absolute. */
			case ORA_Z: /* ORA Zero Matrix. */
				if (opcode == OAB) {
					value = cpu->b[thread];
				}
				cpu->a[thread] |= value;
				setflag(value == 0, Z);
				setflag(value >> 63, N);
				break;
			case SEI: /* SEt Interrupt. */
				setflag(1, I);
				break;
			case BNG: /* BNG Absolute. */
			case BNG_Z: /* BNG Zero Matrix. */
				if (getflag(N))
					cpu->pc[thread] = address;
				break;
			case XOR: /* XOR Immediate. */
			case XAB: /* bitwise Xor with Accumulator, and B register. */
			case XOR_AB: /* XOR Absolute. */
			case XOR_Z: /* XOR Zero Matrix. */
				if (opcode == XAB) {
					value = cpu->b[thread];
				}
				cpu->a[thread] ^= value;
				setflag(value == 0, Z);
				setflag(value >> 63, N);
				break;
			case CLI: /* CLear Interrupt. */
				setflag(0, I);
				break;
			case BCS: /* BCS Absolute. */
			case BCS_Z: /* BCS Zero Matrix. */
				if (getflag(C))
					cpu->pc[thread] = address;
				break;
			case LSL: /* LSL Immediate. */
			case LLB: /* Logical shift Left accumulator by B. */
			case LSL_AB: /* LSL Absolute. */
			case LSL_Z: /* LSL Zero Matrix. */
				if (opcode == LLB) {
					value = cpu->b[thread];
				}
				sum = (value < 64) ? cpu->a[thread] << value : 0;
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(cpu->a[thread] >> 64-value, C);
				cpu->a[thread] = sum;
				break;
			case SEC: /* SEt Carry flag.*/
				setflag(1, C);
				break;
			case STA: /* STA Absolute. */
			case STY: /* STY Absolute. */
			case STX: /* STX Absolute. */
			case STB: /* STB Absolute. */
			case STA_Z: /* STA Zero Matrix. */
			case STY_Z: /* STY Zero Matrix. */
			case STX_Z: /* STX Zero Matrix. */
			case STB_Z: /* STB Zero Matrix. */
			case STA_ZX: /* STA Zero Matrix, Indexed with X. */
			case STY_ZX: /* STY Zero Matrix, Indexed with X. */
			case STX_ZY: /* STX Zero Matrix, Indexed with Y. */
			case STB_ZX: /* STB Zero Matrix, Indexed with X. */
			case STA_ZY: /* STA Zero Matrix, Indexed with Y. */
			case STB_ZY: /* STB Zero Matrix, Indexed with Y. */
			case STY_IN: /* STY Indirect. */
			case STX_IN: /* STX Indirect. */
			case STA_IN: /* STA Indirect. */
			case STB_IN: /* STB Indirect. */
			case STA_IX: /* STA Indexed Indirect. */
			case STB_IX: /* STB Indexed Indirect. */
			case STA_IY: /* STA Indirect Indexed. */
			case STB_IY: /* STB Indirect Indexed. */
				switch (opcode) {
					case STB:
					case STB_Z:
					case STB_ZX:
					case STB_ZY:
					case STB_IN:
					case STB_IX:
					case STB_IY:
						value = cpu->b[thread];
						break;
					case STA:
					case STA_Z:
					case STA_ZX:
					case STA_ZY:
					case STA_IN:
					case STA_IX:
					case STA_IY:
						value = cpu->a[thread];
						break;
					case STY:
					case STY_Z:
					case STY_ZX:
					case STY_IN:
						value = cpu->y[thread];
						break;

					case STX:
					case STX_Z:
					case STX_ZY:
					case STX_IN:
						value = cpu->x[thread];
						break;
				}
				addr[address] = value & 0xFF;
				#if IO
				if (address == TX_ADDR) {
					#if keypoll
					pthread_mutex_lock(&mutex);
					#endif
					if (esc) {
						switch(addr[address]) {
							case 'A':
								if (y > 0)
									y--;
								wmove(scr, y, x);
								esc = 0;
								break;
							case 'B':
								if (y < getmaxy(scr))
									y++;
								wmove(scr, y, x);
								esc = 0;
								break;
							case 'C':
								if (x < getmaxx(scr))
									x++;
								wmove(scr, y, x);
								esc = 0;
								break;
							case 'D':
								if (x > 0)
									x--;
								wmove(scr, y, x);
								esc = 0;
								break;
							case 'H':
								if (!bcd[2] && !bcd[3]) {
									y = 0;
								} else {
									y = ((bcd[3]*10) + bcd[2]);
								}
								if (!bcd[0] && !bcd[1]) {
									x = 0;
								} else {
									x = ((bcd[1]*10) + bcd[0]);
								}
								idx = 3;
								wmove(scr, y, x);
								bcd[0] = 0;
								bcd[1] = 0;
								bcd[2] = 0;
								bcd[3] = 0;
								esc = 0;
								break;
							case 'S':
								wscrl(scr, -1);
								esc = 0;
								break;
							case 'T':
								wscrl(scr, 1);
								esc = 0;
								break;
							case '0':
							case '1':
							case '2':
							case '3':
							case '4':
							case '5':
							case '6':
							case '7':
							case '8':
							case '9':
								bcd[idx--] = (addr[address] - '0');
								break;
							default:
								iscol = (addr[address] == ';');
								break;
						}
					} else {
						if (addr[address] == 0xC) {
							x=0,y=0;
							wclear(scr);
							wmove(scr, y, x);
						} else if (addr[address] == 0x15) {
							x=0;
							wclrtoeol(scr);
							wmove(scr, y, x);
						} else if (addr[address] == CURSES_BACKSPACE || addr[address] == '\b') {
							if (x > 0) {
								x--;
								wmove(scr, y, x);
							}
							wdelch(scr);
						} else if (addr[address] == '\033') {
							esc = 1;
						} else {
							wmove(scr, y, x);
							waddch(scr, addr[address]);
							if (addr[address] == '\n') {
								x = 0;
								y+=1;
							} else {
								x+=1;
							}
						}
					}
					#if keypoll
					pthread_mutex_unlock(&mutex);
					#endif
				}
				#else
				#if !bench
				if (address == TX_ADDR) {
					if (esc) {
						switch(addr[address]) {
							case 'A':
								if (y > 0)
									y--;
								esc = 0;
								break;
							case 'B':
								if (y < getmaxy(scr))
									y++;
								esc = 0;
								break;
							case 'C':
								if (x < getmaxx(scr))
									x++;
								esc = 0;
								break;
							case 'D':
								if (x > 0)
									x--;
								esc = 0;
								break;
							case 'H':
								if (!bcd[2] && !bcd[3])
									y = 0;
								else
									y = ((bcd[3]*10) + bcd[2]);
								if (!bcd[0] && !bcd[1])
									x = 0;
								else
									x = ((bcd[1]*10) + bcd[0]);
								mvwprintw(scr, 30, 0, "x: %i, y: %i  ", x, y);
								mvwprintw(scr, 31, 0, "bcd[3-2]: {%u, %u}, bcd[1-0]: {%u, %u}", bcd[3], bcd[2], bcd[1], bcd[0]);
								updt = 1;
								idx = 3;
								bcd[0] = 0;
								bcd[1] = 0;
								bcd[2] = 0;
								bcd[3] = 0;
								esc = 0;
								break;
							case 'S':
							case 'T':
								esc = 0;
								break;
							case '0':
							case '1':
							case '2':
							case '3':
							case '4':
							case '5':
							case '6':
							case '7':
							case '8':
							case '9':
								bcd[idx--] = (addr[address] - '0');
								break;
							default:
								iscol = (addr[address] == ';');
								break;
						}
					} else {
						if (addr[address] == CURSES_BACKSPACE || addr[address] == '\b') {
							updt = 1;
							if (x > 0) {
								x--;
							}
						} else if (addr[address] == '\033') {
							esc = 1;
						} else {
							updt = (!addr[0x16]);
							if (addr[address] == '\n') {
								x = 0;
								y+=1;
							} else {
								x+=1;
							}
						}
					}
				}
				#endif
				#endif
				switch (regsize) {
					case 8:
						addr[address+7] = value >> 56;
						addr[address+6] = value >> 48;
						addr[address+5] = value >> 40;
						addr[address+4] = value >> 32;
					case 4:
						addr[address+3] = value >> 24;
						addr[address+2] = value >> 16;
					case 2:
						addr[address+1] = value >> 8;
				}
				break;
			case BCC: /* BCC Absolute. */
			case BCC_Z: /* BCC Zero Matrix. */
				if (!getflag(C))
					cpu->pc[thread] = address;
				break;
			case LSR: /* LSR Immediate. */
			case LRB: /* Logical shift Right accumulator by B. */
			case LSR_AB: /* LSR Absolute. */
			case LSR_Z: /* LSR Zero Matrix. */
				if (opcode == LRB) {
					value = cpu->b[thread];
				}
				sum = (value < 64) ? cpu->a[thread] >> value : 0;
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(cpu->a[thread] & 1, C);
				cpu->a[thread] = sum;
				break;
			case ASR: /* ASR Immediate. */
			case ARB: /* Arithmetic shift Right accumulator by B. */
			case ASR_AB: /* ASR Absolute. */
			case ASR_Z: /* ASR Zero Matrix. */
				if (opcode == ARB)
					value = cpu->b[thread];
				sign = cpu->a[thread] & 0x8000000000000000;
				sum = (value < 64) ? (cpu->a[thread] >> value) | sign : 0;
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(cpu->a[thread] & 1, C);
				cpu->a[thread] = sum;
				break;
			case CLC: /* CLear Carry flag. */
				setflag(0, C);
				break;
			case LDB: /* LDB Immediate. */
			case LDA: /* LDA Immediate. */
			case LDY: /* LDY Immediate. */
			case LDX: /* LDX Immediate. */
			case LDB_AB: /* LDB Absolute. */
			case LDA_AB: /* LDA Absolute. */
			case LDY_AB: /* LDY Absolute. */
			case LDX_AB: /* LDX Absolute. */
			case LDB_Z: /* LDB Zero Matrix. */
			case LDA_Z: /* LDA Zero Matrix. */
			case LDY_Z: /* LDY Zero Matrix. */
			case LDX_Z: /* LDX Zero Matrix. */
			case LDB_ZX: /* LDB Zero Matrix, Indexed with X. */
			case LDA_ZX: /* LDA Zero Matrix, Indexed with X. */
			case LDY_ZX: /* LDY Zero Matrix, Indexed with X. */
			case LDX_ZY: /* LDX Zero Matrix, Indexed with Y. */
			case LDB_ZY: /* LDB Zero Matrix, Indexed with Y. */
			case LDA_ZY: /* LDA Zero Matrix, Indexed with Y. */
			case LDB_IN: /* LDY Indirect. */
			case LDA_IN: /* LDX Indirect. */
			case LDY_IN: /* LDB Indirect. */
			case LDX_IN: /* LDA Indirect. */
			case LDB_IX: /* LDB Indexed Indirect. */
			case LDA_IX: /* LDA Indexed Indirect. */
			case LDB_IY: /* LDB Indirect Indexed. */
			case LDA_IY: /* LDA Indirect Indexed. */
				if (address == CTRL_ADDR) {
					kbd_rdy = 1;
					pthread_mutex_lock(&main_mutex);
					pthread_cond_signal(&main_cond);
					pthread_mutex_unlock(&main_mutex);
					#if !keypoll
					pthread_mutex_lock(&mutex);
					pthread_cond_wait(&cond, &mutex);
					pthread_mutex_unlock(&mutex);
					#endif
					kbd_rdy = 0;
				}
				value = addr[address];
				switch (regsize) {
					case 8:
						value |= (uint64_t)addr[address+7] << 56;
						value |= (uint64_t)addr[address+6] << 48;
						value |= (uint64_t)addr[address+5] << 40;
						value |= (uint64_t)addr[address+4] << 32;
					case 4:
						value |= addr[address+3] << 24;
						value |= addr[address+2] << 16;
					case 2:
						value |= addr[address+1] << 8;
				}
				switch (opcode) {
					case LDB:
					case LDB_AB:
					case LDB_Z:
					case LDB_ZX:
					case LDB_ZY:
					case LDB_IN:
					case LDB_IX:
					case LDB_IY:
						cpu->b[thread] = value;
						break;
					case LDA:
					case LDA_AB:
					case LDA_Z:
					case LDA_ZX:
					case LDA_ZY:
					case LDA_IN:
					case LDA_IX:
					case LDA_IY:
						cpu->a[thread] = value;
						break;
					case LDY:
					case LDY_AB:
					case LDY_Z:
					case LDY_ZX:
					case LDY_IN:
						cpu->y[thread] = value;
						break;

					case LDX:
					case LDX_AB:
					case LDX_Z:
					case LDX_ZY:
					case LDX_IN:
						cpu->x[thread] = value;
						break;
				}
				setflag(value == 0, Z);
				setflag(value >> 63, N);
				break;
			case BEQ: /* BEQ Absolute. */
			case BEQ_Z: /* BEQ Zero Matrix. */
				if (getflag(Z))
					cpu->pc[thread] = address;
				break;
			case ROL: /* ROL Immediate. */
			case RLB: /* Rotate Left accumulator by B. */
			case ROL_AB: /* ROL Absolute. */
			case ROL_Z: /* ROL Zero Matrix. */
				if (opcode == RLB) {
					value = cpu->b[thread];
				}
				sum = cpu->a[thread] << value;
				sum |= getflag(C);
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(cpu->a[thread] >> (uint64_t)64-value, C);
				cpu->a[thread] = sum;
				break;
			case BNE: /* BNE Absolute. */
			case BNE_Z: /* BNE Zero Matrix. */
				if (!getflag(Z))
					cpu->pc[thread] = address;
				break;
			case ROR: /* ROR Immediate. */
			case RRB: /* Rotate Right accumulator by B. */
			case ROR_AB: /* ROR Absolute. */
			case ROR_Z: /* ROR Zero Matrix. */
				if (opcode == RRB) {
					value = cpu->b[thread];
				}
				sum = cpu->a[thread] >> value;
				sum |= (uint64_t)getflag(C) << (uint64_t)64-value;
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(cpu->a[thread] & 1, C);
				cpu->a[thread] = sum;
				break;
			case BVS: /* BVS Absolute. */
			case BVS_Z: /* BVS Zero Matrix. */
				if (getflag(V))
					cpu->pc[thread] = address;
				break;
			case MUL: /* MUL Immediate. */
			case MAB: /* Multiply Accumulator by B. */
			case MUL_AB: /* MUL Absolute. */
			case MUL_Z: /* MUL Zero Matrix. */
				if (opcode == MAB) {
					value = cpu->b[thread];
				}
				sum = cpu->a[thread]*value+getflag(C);
				cpu->a[thread] = sum;
				setflag(sum == 0, Z);
				setflag(sum >> 63, N);
				setflag(!((cpu->a[thread]^value) & 0x8000000000000000) && ((cpu->a[thread]^sum) & 0x8000000000000000), V);
				setflag((!((cpu->a[thread]^sum) && (cpu->a[thread]^value)) && (cpu->a[thread] >= ((uint64_t)1 << 32) && value >= ((uint64_t)1 << 32))), C);
				break;
			case BVC: /* BVC Absolute. */
			case BVC_Z: /* BVC Zero Matrix. */
				if (!getflag(V))
					cpu->pc[thread] = address;
				break;
			case DIV: /* DIV Immediate. */
			case DAB: /* Divide Accumulator by B. */
			case DIV_AB: /* DIV Absolute. */
			case DIV_Z: /* DIV Zero Matrix. */
				if (opcode != DAB) {
					cpu->b[thread] = cpu->a[thread] % value;
				} else {
					value = cpu->b[thread];
					cpu->x[thread] = cpu->a[thread] % value;
				}
				sum = cpu->a[thread]/value;
				cpu->a[thread] = sum;
				setflag(sum == 0, Z);
				setflag((sum >> 63), N);
				break;
			case CLV: /* CLear oVerflow flag. */
				setflag(0, V);
				break;
			case RTS: /* ReTurn from Subroutine. */
				tmp2 = 0;
				switch (addrsize) {
					case 3: stksize = 3; break;
					case 2: stksize = 5; break;
					case 1: stksize = 2; break;
					case 0: stksize = 0; break;
				}
				cpu->sp[thread]++;reg = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;stksize--;
				switch (stksize) {
					case 4:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 3:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 2:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 1:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 0:	cpu->sp[thread]++;tmp2++;reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
				}
				break;
			case CPB: /* CPB Immediate. */
			case CMP: /* CMP Immediate. */
			case CAB: /* Compare Accumulator, and B. */
			case CPY: /* CPY Immediate. */
			case CPX: /* CPX Immediate. */
			case CPY_AB: /* CPY Absolute. */
			case CPX_AB: /* CPX Absolute. */
			case CMP_AB: /* CMP Absolute. */
			case CPB_AB: /* CPB Absolute. */
			case CPY_Z: /* CPY Zero Matrix. */
			case CPX_Z: /* CPX Zero Matrix. */
			case CMP_Z: /* CMP Zero Matrix. */
			case CPB_Z: /* CPB Zero Matrix. */
			case CPY_IN: /* CMP Indirect. */
			case CPX_IN: /* CPY Indirect. */
			case CMP_IN: /* CPX Indirect. */
			case CPB_IN: /* CPB Indirect. */
			case CMP_IX: /* CMP Indexed Indirect. */
			case CPB_IX: /* CPB Indexed Indirect. */
			case CMP_IY: /* CMP Indirect Indexed. */
			case CPB_IY: /* CPB Indirect Indexed. */
				if (opcode == CAB) {
					value = cpu->b[thread];
				}
				switch (opcode) {
					case CPB:
					case CPB_AB:
					case CPB_Z:
					case CPB_IN:
					case CPB_IX:
					case CPB_IY:
						reg = cpu->b[thread];
						break;
					case CMP:
					case CAB:
					case CMP_AB:
					case CMP_Z:
					case CMP_IN:
					case CMP_IX:
					case CMP_IY:
						reg = cpu->a[thread];
						break;
					case CPY:
					case CPY_AB:
					case CPY_Z:
					case CPY_IN:
						reg = cpu->y[thread];
						break;

					case CPX:
					case CPX_AB:
					case CPX_Z:
					case CPX_IN:
						reg = cpu->x[thread];
						break;
				}
				sum = reg-value;
				setflag(sum >> 63, N);
				setflag(((reg^value) & 0x8000000000000000) && ((reg^sum) & 0x8000000000000000), V);
				setflag(sum == 0, Z);
				setflag(reg >= value, C);
				break;
			case ENT: /* ENd Thread. */
				cpu->crt &= ~value;
				for (uint8_t i = 0; i < 7; i++)
					if ((value >> i) & 1)
						cpu->pc[i+1] = cpu->pc[0]+(i+1);
				break;
			case RTI: /* ReTurn from Interrupt routine. */
				cpu->sp[thread] += 9;
				cpu->ps	= addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-8)] << (thread << 3);
				cpu->pc[thread]  = (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-7)];
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-6)] <<  8;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-5)] << 16;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-4)] << 24;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-3)] << 32;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-2)] << 40;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-1)] << 48;
				cpu->pc[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]]     << 56;
				break;
			case INC: /* INC Accumulator. */
			case INB:
			case INY:
			case INX:
				switch (opcode) {
					case INC:
						cpu->a[thread]+=1;
						setflag(cpu->a[thread] == 0, Z);
						setflag((cpu->a[thread] >> 63), N);
						break;
					case INB:
						cpu->b[thread]+=1;
						setflag(cpu->b[thread] == 0, Z);
						setflag((cpu->b[thread] >> 63), N);
						break;
					case INY:
						cpu->y[thread]+=1;
						setflag(cpu->y[thread] == 0, Z);
						setflag((cpu->y[thread] >> 63), N);
						break;
					case INX:
						cpu->x[thread]+=1;
						setflag(cpu->x[thread] == 0, Z);
						setflag((cpu->x[thread] >> 63), N);
						break;
				}
				break;
			case DEC: /* DEC Accumulator. */
			case DEB:
			case DEY:
			case DEX:
				switch (opcode) {
					case DEC:
						cpu->a[thread]-=1;
						setflag(cpu->a[thread] == 0, Z);
						setflag((cpu->a[thread] >> 63), N);
						break;
					case DEB:
						cpu->b[thread]-=1;
						setflag(cpu->b[thread] == 0, Z);
						setflag((cpu->b[thread] >> 63), N);
						break;
					case DEY:
						cpu->y[thread]-=1;
						setflag(cpu->y[thread] == 0, Z);
						setflag((cpu->y[thread] >> 63), N);
						break;
					case DEX:
						cpu->x[thread]-=1;
						setflag(cpu->x[thread] == 0, Z);
						setflag((cpu->x[thread] >> 63), N);
						break;
				}
				break;
			case JSL: /* Jump to Subroutine Long. */
				switch (addrsize) {
					case 3: stksize = 7; break;
					case 2: stksize = 6; break;
					case 1: stksize = 4; break;
					case 0: stksize = 1; break;
				}
				switch (stksize) {
					case 7:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (7<<3);cpu->sp[thread]--;
					case 6:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (6<<3);cpu->sp[thread]--;
					case 5:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (5<<3);cpu->sp[thread]--;
					case 4:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (4<<3);cpu->sp[thread]--;
					case 3:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (3<<3);cpu->sp[thread]--;
					case 2:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (2<<3);cpu->sp[thread]--;
					case 1:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> (1<<3);cpu->sp[thread]--;
					case 0:	addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] & 0xFF;   cpu->sp[thread]--;
				}
				cpu->pc[thread] = address;
				break;
			case INC_AB: /* INC Absolute. */
			case INC_Z: /* INC Zero Matrix. */
				addr[address]++;
				setflag(addr[address] == 0, Z);
				setflag(addr[address] >> 7, N);
				break;
			case NOP: /* No OPeration. */
				break;
			case RTL: /* ReTurn from subroutine Long. */
				tmp2 = 1;
				switch (addrsize) {
					case 3: stksize = 7; break;
					case 2: stksize = 6; break;
					case 1: stksize = 4; break;
					case 0: stksize = 0; break;
				}
				cpu->sp[thread] += 2;
				stksize -= 2;
				cpu->pc[thread]  = addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-1)] & 0xFF;
				cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << 8;
				switch (stksize) {
					case 5:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 4:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 3:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 2:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 1:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
					case 0:	cpu->sp[thread]++;tmp2++;cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << (tmp2<<3);
				}
				break;
				break;
			case DEC_AB: /* DEC Absolute. */
			case DEC_Z: /* DEC Zero Matrix. */
				addr[address]--;
				setflag(addr[address] == 0, Z);
				setflag(addr[address] >> 7, N);
				break;
			case BRK: /* BReaK. */
				addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]]     = (uint64_t)cpu->pc[thread] >> 56;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-1)] = (uint64_t)cpu->pc[thread] >> 48;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-2)] = (uint64_t)cpu->pc[thread] >> 40;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-3)] = (uint64_t)cpu->pc[thread] >> 32;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-4)] = (uint64_t)cpu->pc[thread] >> 24;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-5)] = (uint64_t)cpu->pc[thread] >> 16;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-6)] = (uint64_t)cpu->pc[thread] >> 8;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-7)] = (uint64_t)cpu->pc[thread] & 0xFF;
				addr[(cpu->stk_st[thread] << 16)+(cpu->sp[thread]-8)] = (uint64_t)cpu->ps >> (thread << 3);
				cpu->sp[thread] -= 9;
				setflag(1, I);
				cpu->pc[thread]  = (uint64_t)addr[0xFFE0];
				cpu->pc[thread]	+= (uint64_t)addr[0xFFE1] << 8;
				cpu->pc[thread] += (uint64_t)addr[0xFFE2] << 16;
				cpu->pc[thread] += (uint64_t)addr[0xFFE3] << 24;
				cpu->pc[thread] += (uint64_t)addr[0xFFE4] << 32;
				cpu->pc[thread] += (uint64_t)addr[0xFFE5] << 40;
				cpu->pc[thread] += (uint64_t)addr[0xFFE6] << 48;
				cpu->pc[thread] += (uint64_t)addr[0xFFE7] << 56;
				break;
			case WAI: /* WAit for Interrupt. */
				wai = 1;
				pthread_mutex_lock(&main_mutex);
				pthread_cond_signal(&main_cond);
				pthread_mutex_unlock(&main_mutex);
				pthread_mutex_lock(&mutex);
				pthread_cond_wait(&cond, &mutex);
				pthread_mutex_unlock(&mutex);
				break;
			default:
				break;
		}
		ins++;
		step = addr[STEP_ADDR];
		if (step) {
			pthread_mutex_lock(&main_mutex);
			pthread_cond_signal(&main_cond);
			pthread_mutex_unlock(&main_mutex);
			pthread_mutex_lock(&mutex);
			pthread_cond_wait(&cond, &mutex);
			pthread_mutex_unlock(&mutex);
			#if debug && !bench
			wrefresh(scr);
			#endif
		}
		if (!addr[CTRL_ADDR])
			kbd_ln = 0;
		else
			kbd_ln = 1;

	#if debug && !bench
		#if keypoll
		pthread_mutex_lock(&mutex);
		#endif
		mvwprintw(scr, (6*thread)+1, 0, "Instructions executed: %llu, Clock cycles: %llu\r", ins, iclk);
		if (!step) {
			wrefresh(scr);
		}
		#if keypoll
		pthread_mutex_unlock(&mutex);
		#endif
	#endif
	#if bench
		if (ins >= BENCH_INST) {
			end = 1;
			pthread_mutex_lock(&main_mutex);
			threads_done++;
			inst[thread] = ins;
			clk[thread] = iclk;
			pthread_cond_signal(&main_cond);
			pthread_mutex_unlock(&main_mutex);
			gettimeofday(&en[thread], 0);
		}
	#endif
	}
	free(s);
}

int main(int argc, char **argv) {
	struct suxthr thr[THREADS];
	char *tmp = malloc(2048);
	ibcount = 0;
	addr = malloc(0x04000000);
	inss = 0;
	int v = 0;

	if (argc != 2) {
		if (asmmon("stdin") == 2)
			return 0;
	} else {
		if (asmmon(argv[1]) == 2)
			return 0;
	}
	sprintf(tmp, "\033[2J\033[H");
	fwrite(tmp, sizeof(char), strlen(tmp), stdout);
	fflush(stdout);
#if !bench
	if(!scr)
		scr = initscr();
	nodelay(stdscr, 0);
	crmode();
	noecho();
	nl();
	curs_set(1);
	werase(scr);
	scrollok(scr, 1);
	wrefresh(scr);
	start_color();
	use_default_colors();
	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))]
					| (uint64_t)addr[0xFF51+(8*(i-1))] << 8
					| (uint64_t)addr[0xFF52+(8*(i-1))] << 16
					| (uint64_t)addr[0xFF53+(8*(i-1))] << 24
					| (uint64_t)addr[0xFF54+(8*(i-1))] << 32
					| (uint64_t)addr[0xFF55+(8*(i-1))] << 40
					| (uint64_t)addr[0xFF56+(8*(i-1))] << 48
					| (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]
					| (uint64_t)addr[0xFFC1] << 8
					| (uint64_t)addr[0xFFC2] << 16
					| (uint64_t)addr[0xFFC3] << 24
					| (uint64_t)addr[0xFFC4] << 32
					| (uint64_t)addr[0xFFC5] << 40
					| (uint64_t)addr[0xFFC6] << 48
					| (uint64_t)addr[0xFFC7] << 56;
		}
		thr[i].th = i;
	}
	pthread_t therads[THREADS];
	int result;
	for (int i = 0; i < THREADS; i++) {
		inst[i] = 0;
	}
	for (int i = 0; i < THREADS; i++) {
		result = pthread_create(&therads[i], NULL, run, &thr[i]);
		assert(!result);
	}
	int c = 0;
	uint8_t step_key = 0;
#if !bench
	werase(scr);
#endif
	while (threads_done < THREADS) {
		#if !bench
		int x, y, i = 0;
		if ((step_key && step && !kbd_rdy) || !step || kbd_rdy) {
			if ((c != EOF && c !=-1)) {
				pthread_mutex_lock(&main_mutex);
				curs_set(0);
				pthread_cond_wait(&main_cond, &main_mutex);
				pthread_mutex_unlock(&main_mutex);
				curs_set(1);
				c = 0;
				step_key = 0;
				addr[CTRL_ADDR] = 0;
				kbd_ln = 0;
				#if !debug
				wrefresh(scr);
				#endif
			}
		}
		#if keypoll
		pthread_mutex_lock(&mutex);
		#endif
		getyx(scr, y, x);
		c = wgetch(scr);
		if (c == 19) {
			step = 1;
			if (kbd_rdy)
				c = wgetch(scr);
		}
		if (kbd_rdy) {
			switch (c) {
				case ERR:
					addr[CTRL_ADDR] = 0;
					wmove(scr, getmaxy(scr)-1, 0);
					wprintw(scr, "c: %i, x: %i, y: %i, i: %i.", c, x, y, i++);
					wmove(scr, y, x);
					wrefresh(scr);
					break;
				default:
					if (kbd_rdy && c < 0x100) {
						addr[RX_ADDR] = (uint8_t)c;
						addr[CTRL_ADDR] = 1;
						#if debug && !bench
						wmove(scr, getmaxy(scr)-1, 0);
						wprintw(scr, "c: %i, x: %i, y: %i, i: %i.", c, x, y, i++);
						wmove(scr, y, x);
						wrefresh(scr);
						#endif
					}
					if (c == '\n')
						kbd_ln = 1;
					#if !keypoll
					pthread_mutex_lock(&mutex);
					pthread_cond_signal(&cond);
					pthread_mutex_unlock(&mutex);
					#endif
					break;
			}
		} else {
			if ((c == 19 || c == 18) && step) {
				if (c == 18)
					step = 0;
				else if (c == 19)
					step_key = 1;
				#if !keypoll
				pthread_mutex_lock(&mutex);
				pthread_cond_signal(&cond);
				pthread_mutex_unlock(&mutex);
				#endif
			}
		}
		addr[STEP_ADDR] = step;
		#if keypoll
		pthread_mutex_unlock(&mutex);
		#endif
		#else
		pthread_mutex_lock(&main_mutex);
		pthread_cond_wait(&main_cond, &main_mutex);
		pthread_mutex_unlock(&main_mutex);
		#endif
	}
#if bench
	if (threads_done == THREADS) {
		double tm_sec, tm_usec, tm[THREADS], ttm;
		double clkspd;
		double mhz;
		double ips[THREADS];
		double ipst;
		for (int i = 0; i < THREADS; i++) {
			tm_sec = (en[i].tv_sec - str[i].tv_sec);
			tm_usec = (en[i].tv_usec-str[i].tv_usec);
			tm[i] = (tm_sec*1000000)+(tm_usec);
			ips[i] = inst[i]/tm[i];
			if (i) {
				inss += inst[i];
				ttm += tm[i];
				ipst += ips[i];
				tclk += clk[i];
			} else {
				inss = inst[i];
				ttm = tm[i];
				ipst = ips[i];
				tclk = clk[i];
			}
			clkspd = (tm[i]/1000000)*1000000/clk[i];
			mhz = 1000000.0/clkspd/1000000;
			sprintf(tmp, "Instructions executed for thread %i: %llu, Instructions per Second for thread %i in MIPS: %f, tm: %f\n", i, inst[i], i, ips[i], tm[i]/1000000);
			fwrite(tmp, sizeof(char), strlen(tmp), stdout);
		}
		clkspd = (ttm/1000000)*1000000/tclk;
		mhz = 1000000.0/clkspd/1000000;
		sprintf(tmp, "Total Instructions executed: %llu, Total Instructions per Second in MIPS: %f, Clock cycles: %llu, Clock Speed in MHz: %f, tm: %f\n", inss, ipst, tclk, mhz, ttm/1000000);
		fwrite(tmp, sizeof(char), strlen(tmp), stdout);
		fflush(stdout);
		free(tmp);
	}
#endif
	free(addr);
	return 0;
}