- Fixed some bugs in the emulator.

- Started work on implementing the Super VIA emulation.
- Added support for disabling disassembly per
  instruction, when in debug mode.
- Did some more work on rewriting the SuB Suite to
  work with the new calling convention.
- Rewrote the symbol handling code in the emulator's
  assembler, to make it both simpler, and to add
  support for arbitrarily deep symbol scopes.
- Added support for arbitrarily deep local symbol
  scopes.

  For example, to declare a symbol of depth 2, you add
  two '@' characters to the start of the symbol name.

  In other words, the number of '@' characters before
  the symbol name is what determines the scope of that
  symbol.

  And to use a symbol thats outside the current
  scope, you would use the same syntax as using a
  struct member, so you would do `global.local`.

22 files changed, 1970 insertions, 1277 deletions

diff --git a/asmmon.c b/asmmon.c
index 0890076..81edff2 100644
--- a/asmmon.c
+++ b/asmmon.c
@@ -305,7 +305,7 @@ void list(uint16_t start, uint16_t end, uint8_t all, uint8_t ln, uint8_t addr, u
 			if (t->next && !isopdone(t)) {
 				op_done = isopdone(t->next);
 			}
-			if (am != 0xFF && op_done && t->id != TOK_RS && !t->next) {
+			if (am != 0xFF && op_done && t->id != TOK_RS) {
 				switch (am) {
 					case EIND: putchar('('); am_done = 0; break;
 					case BREG: putchar('b'); am_done = 1; break;
@@ -418,10 +418,16 @@ int asmmon(const char *fn) {
 						case PTOK_DQUOTE :
 						case PTOK_SQUOTE :
 						case PTOK_B      :
+						case PTOK_E      :
 						case PTOK_X      :
 						case PTOK_Y      :
 						case PTOK_S      :
 						case PTOK_P      :
+						case PTOK_A      :
+						case PTOK_C      :
+						case PTOK_D      :
+						case PTOK_F      :
+						case PTOK_R      :
 						case PTOK_MINUS  :
 						case PTOK_PLUS   : is_valid = 1;           break;
 						default          : is_valid = 0; stop = 1; break;
@@ -440,7 +446,7 @@ int asmmon(const char *fn) {
 					case 'h': cmds = (isshcmd || !strcasecmp(cmd, "help"   )) << 4; break;
 					case 'i': cmds = (isshcmd || !strcasecmp(cmd, "inst"   )) << 5; break;
 					case 'd': cmds = (isshcmd || !strcasecmp(cmd, "done"   )) << 6; break;
-					case 's': cmds = (isshcmd || !strcasecmp(cmd, "set"    )) << 7; break;
+					case 's': cmds = (isshcmd || !strcasecmp(cmd, "sett"    )) << 7; break;
 					case ' ':
 					case '\t':
 					default:
diff --git a/asmmon.h b/asmmon.h
index 7ed879b..de1f732 100644
--- a/asmmon.h
+++ b/asmmon.h
@@ -4,11 +4,11 @@
 
 #define MAX_TOK 0x1000
 
-typedef struct tok  token	;
-typedef struct ln   line	;
-typedef struct sym  symbol	;
-typedef struct fix  fixup	;
-typedef struct inst instruction	;
+typedef struct tok token;
+typedef struct ln line;
+typedef struct sym symbol;
+typedef struct fix fixup;
+typedef struct inst instruction;
 
 
 struct tok {
@@ -59,6 +59,7 @@ struct sym {
 	symbol *prev;
 	symbol *down;
 	symbol *up;
+	int depth;
 	uint16_t count;
 	uint64_t val;
 	uint8_t isstruct : 1;
@@ -88,6 +89,7 @@ extern symbol *locals;
 extern symbol *last_loc;
 extern fixup *fixups;
 extern fixup *last_fix;
+extern tmp_symtab *tmp_sym_table;
 
 extern uint8_t lex_type;
 
diff --git a/assemble.c b/assemble.c
index 91972eb..f4de278 100644
--- a/assemble.c
+++ b/assemble.c
@@ -479,8 +479,10 @@ token *get_operands(token *t, operand *op, uint64_t address, uint8_t rs, uint8_t
 	}*/
 
 	for (; t && i < 2; t = t->next) {
+		reg = (old_i != i) ? 0 : reg;
+		got_value = (old_i != i) ? 0 : got_value;
 		if (t->subtype == TOK_IND) {
-			brack_done = 1;
+			brack_done = (t->id == TOK_REG) ? 2 : 1;
 		}
 		switch (t->id) {
 			case TOK_HEX  :
@@ -544,8 +546,8 @@ token *get_operands(token *t, operand *op, uint64_t address, uint8_t rs, uint8_t
 				} else {
 					if (op[i].type == 1) {
 						if (op[i].id == MEM_IND) {
-							op[i].id = (!brack_done && got_value) ? MEM_ZRIND : MEM_RIND;
-							op[i].id = (brack_done && got_value) ? MEM_ZINDR : op[i].id;
+							op[i].id = ((!brack_done || brack_done == 2) && got_value) ? MEM_ZRIND : MEM_RIND;
+							op[i].id = (brack_done == 1 && got_value) ? MEM_ZINDR : op[i].id;
 							brack_done = 0;
 						} else {
 							op[i].id = (got_value) ? MEM_ZMR : op[i].id;
@@ -578,7 +580,6 @@ token *get_operands(token *t, operand *op, uint64_t address, uint8_t rs, uint8_t
 				op[0].cc = t->byte;
 				i = 3;
 				break;
-
 		}
 		if (!t) {
 			break;
@@ -737,6 +738,13 @@ uint64_t handle_opcode(token *t, bytecount *bc, uint8_t isasm, uint64_t address,
 					i = 8;
 					for (; i <= 64; i += 8, j++) {
 						max_val |= ((uint64_t)1 << (i-1));
+						/*int64_t tmp_val = (int64_t)op[0].value;
+						int is_pos = (tmp_val >= 0);
+						int is_neg = (tmp_val <  0);
+						if ((is_pos && tmp_val <= ~(int64_t)(max_val)) || (is_neg && tmp_val >= (int64_t)(max_val))) {
+							opsize = j;
+							break;
+						}*/
 						if ((int64_t)op[0].value >= ~(int64_t)(max_val) || (int64_t)op[0].value <= (int64_t)(max_val)) {
 							opsize = j;
 							break;
@@ -917,6 +925,7 @@ uint64_t handle_opcode(token *t, bytecount *bc, uint8_t isasm, uint64_t address,
 			if (op[0].cc != 0xFF && op[0].cc < 8) {
 				opcode |= (op[0].cc << 5);
 			}
+			uint8_t tmp_size = 0;
 			for (int i = 0; i < 2 && op[i].type != 0xFF; i++) {
 				int i2 = 0;
 				int j = 0;
@@ -936,17 +945,20 @@ uint64_t handle_opcode(token *t, bytecount *bc, uint8_t isasm, uint64_t address,
 							if (op[i].id != MEM_IND && op[i].id != 0xFF) {
 								max_val = 0;
 								for (i2 = 8, j = 1; i2 <= 64; i2 += 8, j++) {
-									max_val |= ((uint64_t)1 << (i2-1));
-									if ((int64_t)op[i].value >= ~(int64_t)(max_val) || (int64_t)op[i].value <= (int64_t)(max_val)) {
+									max_val = ((uint64_t)1 << (i2-1));
+									int64_t tmp_val = (int64_t)op[i].value;
+									int is_pos = (tmp_val >= 0);
+									int is_neg = (tmp_val <  0);
+									if ((is_pos && tmp_val <= (int64_t)(max_val-1)) || (is_neg && tmp_val >= -(int64_t)(max_val))) {
 										opsize = j;
 										break;
 									}
 								}
 							} else {
 								max_val = 0;
-								for (i2 = 8, j = 1; i2 <= 64; i2 += 8, j++) {
+								for (i2 = 0, j = 1; i2 <= 64; i2 += 8, j++) {
 									max_val |= (0xFF << i2);
-									if (op[0].value <= max_val) {
+									if (op[i].value <= max_val) {
 										opsize = j;
 										break;
 									}
@@ -965,13 +977,14 @@ uint64_t handle_opcode(token *t, bytecount *bc, uint8_t isasm, uint64_t address,
 							}
 							if (opsize) {
 								uint8_t is_abs = (type == ABS);
-								if (!is_abs) {
+								/*if (!is_abs) {
 									switch (opsize) {
 										case 2: opsize = 3; break;
 										case 5: opsize = 6; break;
 									}
-								}
+								}*/
 								prefix |= amp[opsize-1];
+								/*tmp_size = (opsize >= tmp_size) ? opsize : tmp_size;*/
 							}
 							op_size[i] = opsize;
 							if (isasm && dbg) {
@@ -981,6 +994,11 @@ uint64_t handle_opcode(token *t, bytecount *bc, uint8_t isasm, uint64_t address,
 					}
 				}
 			}
+			/*if (tmp_size) {
+				prefix |= amp[tmp_size-1];
+			}*/
+			/*op_size[0] = tmp_size;
+			op_size[1] = tmp_size;*/
 		}
 		inst_size = write_inst(prefix, ext_prefix, opcode, op, address, op_size, isasm, dbg);
 		address += inst_size;
@@ -1218,7 +1236,7 @@ void fix_symtree(line *l) {
 	}
 }
 
-static inline void free_tokens(token *t) {
+static void free_tokens(token *t) {
 	token *tok;
 	if (t != NULL) {
 		tok = t;
@@ -1257,7 +1275,7 @@ static void free_symbols(symbol *s) {
 	}
 }
 
-static inline void free_fixups(fixup *f) {
+static void free_fixups(fixup *f) {
 	fixup *fix;
 	if (f != NULL) {
 		fix = f;
@@ -1268,6 +1286,17 @@ static inline void free_fixups(fixup *f) {
 	}
 }
 
+static inline void free_tmp_symtab(tmp_symtab *st) {
+	tmp_symtab *tmp;
+	if (st != NULL) {
+		tmp = st;
+		st = st->next;
+		free(tmp);
+		tmp = NULL;
+		free_tmp_symtab(st);
+	}
+}
+
 uint64_t get_tokmem(token *t) {
 	uint64_t i = 0;
 	for (; t; t = t->next, i++);
@@ -1298,6 +1327,10 @@ void cleanup() {
 		free_fixups(fixups);
 		fixups = NULL;
 	}
+	if (tmp_sym_table) {
+		free_tmp_symtab(tmp_sym_table);
+		tmp_sym_table = NULL;
+	}
 	while (i < stridx || i < comidx) {
 		if (i < stridx && string[i]) {
 			free(string[i]);
diff --git a/disasm.c b/disasm.c
index b79d55b..1982c17 100644
--- a/disasm.c
+++ b/disasm.c
@@ -59,6 +59,7 @@ static void sub_dbg(struct sux *cpu, WINDOW *w, uint64_t address, uint64_t *orth
 		adr = read_value(cpu, 0, tmpad, 7, 0, 0);
 		tmpad += 8;
 		wmove(w, 1, 0);
+		wclrtoeol(w);
 		wprintw(w, "scr_row: %02u, scr_col: %02u, scr_str: %02u, scr_end: %02u", addr[0], addr[1], addr[2], addr[3]);
 		wmove(w, 2, 0);
 		wprintw(w, "bitabl: ");
@@ -173,11 +174,10 @@ static uint64_t get_offset(uint64_t value, uint8_t size, char **sign) {
 	size = (size > 8) ? 8 : size;
 	uint8_t msb = size*8;
 	uint64_t mask = (-(uint64_t)1 >> ((8 - size) * 8));
-	mask &= (1 << (msb-1));
+	mask &= ~(1 << (msb-1));
 	*sign = ((value >> (msb-1)) & 1) ? "-" : "+";
-	if (*sign[0] == '-') {
-		value &= mask;
-		value = -(value+1);
+	if (*sign[0] == '-' && value != (1 << (msb-1))) {
+		value = (-value) & mask;
 	}
 	return value;
 }
@@ -301,10 +301,6 @@ static void disasm_ortho(struct sux *cpu, WINDOW *w, uint8_t opcode, uint8_t pre
 		uint64_t val = 0;
 		if (op[i].type) {
 			uint8_t addr_size = get_ortho_addrsize(prefix, op[i].id);
-			if (addr_size != 0xFF) {
-				uint64_t value = get_offset(op[i].value, addr_size+1, &sign[i]);
-				sprintf(address[i], "$%0*"PRIX64, (addr_size+1)*2, value);
-			}
 			if (op[i].id == MEM_SIB) {
 				sprintf(scale[i], "%u*", op[i].scale+1);
 			} else if (op[i].id == MEM_IMM) {
@@ -321,6 +317,10 @@ static void disasm_ortho(struct sux *cpu, WINDOW *w, uint8_t opcode, uint8_t pre
 				case MEM_SIB  :
 				case MEM_RIND : is_rind = 1; break;
 			}
+			if (addr_size != 0xFF) {
+				uint64_t value = (is_rind) ? get_offset(op[i].value, addr_size+1, &sign[i]) : op[i].value;
+				sprintf(address[i], "$%0*"PRIX64, (addr_size+1)*2, value);
+			}
 			if (is_rind) {
 				for (int j = 0; j < 2 && op[i].rind[j] != 0xFF; j++) {
 					switch (op[i].rind[j]) {
diff --git a/io.c b/io.c
index e19f194..9848e8d 100644
--- a/io.c
+++ b/io.c
@@ -48,6 +48,7 @@ int get_key(WINDOW *scr) {
 	int x, y;
 	int c;
 	int keycode = 0;
+	int tmp_flag = dbg_print_per_inst;
 	curs_set(1);
 	if ((key == NULL) || (key && key[key_idx] == '\0') || !kbd_rdy) {
 		c = wgetch(scr);
@@ -89,12 +90,17 @@ int get_key(WINDOW *scr) {
 					wrefresh(regs);
 					#endif
 					break;
+				case KEY_F(3):
+					dbg_print_per_inst = !dbg_print_per_inst;
 			}
 			#if debug && !bench
 			getyx(scr, y, x);
 			wmove(scr, getmaxy(scr)-1, 0);
 			wclrtoeol(scr);
 			wprintw(scr, "keycode: %i", keycode);
+			if (tmp_flag != dbg_print_per_inst) {
+				wprintw(scr, ", Disassemble per instruction %s", (dbg_print_per_inst) ? "enabled" : "disabled");
+			}
 			wmove(scr, y, x);
 			#endif
 		}
@@ -235,10 +241,16 @@ void reset_esc() {
 void handle_ctrlcode(int c) {
 	int x, y;
 	uint16_t scr_col = 0;
+	int tmp_flag = 0;
 	#if debug
-	if (!subdbg) {
-		scr_col = (addr[TX_ADDR] != 0x0C && addr[TX_ADDR] != '\n' && scr_col < 160) ? (addr[1] << 1)-2 : 0;
-		wmove(scr, 28, scr_col);
+	if (subdbg) {
+		tmp_flag = (addr[TX_ADDR] != 0x0C && addr[TX_ADDR] != '\n' && scr_col < 160);
+		if (!tmp_flag) {
+			wmove(scr, 30, 0);
+			wclrtoeol(scr);
+		}
+		scr_col = (tmp_flag) ? (addr[1] << 1)-2 : 0;
+		wmove(scr, 30, scr_col);
 	}
 	#endif
 	getyx(scr, y, x);
@@ -261,11 +273,11 @@ void handle_ctrlcode(int c) {
 			#if !debug
 			wdelch(scr);
 			#else
-			if (!subdbg) {
+			if (subdbg) {
 				scr_col++;
-				wmove(scr, 28, scr_col--);
+				wmove(scr, 30, scr_col--);
 				wdelch(scr);
-				wmove(scr, 28, scr_col);
+				wmove(scr, 30, scr_col);
 				wdelch(scr);
 			}
 			#endif
@@ -283,7 +295,7 @@ void handle_ctrlcode(int c) {
 			/*wmove(scr, y, x);*/
 			waddch(scr, c);
 			#else
-			if (!subdbg && scr_col < 160) {
+			if (subdbg && scr_col < 160) {
 				if (c != ' ') {
 					wprintw(scr, "%02X", c);
 				} else {
diff --git a/lexer.c b/lexer.c
index bb3701a..57a7e14 100644
--- a/lexer.c
+++ b/lexer.c
@@ -10,97 +10,193 @@ symbol *last_loc = NULL;
 symbol *cur_sym = NULL;
 symbol *struct_sym = NULL;
 
+
 line *tmp_line = NULL;
 
-symbol *mksymbol(const char *name, uint64_t val, uint8_t def, uint8_t islocal, uint8_t useid, uint16_t id, uint8_t dbg) {
-	uint16_t i = 0;
-	symbol *s = (!islocal) ? symbols : locals;
-	uint8_t flag = 0;
-	for (; s; s = s->next, i++) {
-		if (!useid && name[0] != s->name[0]) {
-			continue;
-		}
-		flag = (useid) ? (id == s->id) : !strcmp(name, s->name);
-		if (flag) {
-			if (def) {
-				if (s->def) {
-					if (dbg) {
-						printf("mksymbol(): oof, you cannot redefine the symbol: %s\n", name);
+symbol *find_symbol(symbol *root, const char *name, int depth, uint8_t dbg) {
+	symbol *s = root;
+	symbol *ret = NULL;
+	char *tmp = malloc(strlen(name)+1);
+	memcpy(tmp, name, strlen(name)+1);
+	char *scope_name = strtok_r(tmp, ".", &tmp);
+	size_t name_len = strlen(scope_name);
+	for (; s != NULL; s = s->next) {
+		size_t sym_name_len = strlen(s->name);
+		if (name_len == sym_name_len && scope_name[0] == s->name[0] && !strcmp(scope_name, s->name)) {
+			if (depth) {
+				if (s->down) {
+					ret = find_symbol(s->down, (tmp == NULL) ? scope_name : tmp, depth-1, dbg);
+					if (ret) {
+						return ret;
 					}
-					defined = 1;
-				} else {
-					defined = 0;
-				}
-				s->def = def;
-				s->val = val;
-				s->id = i;
-				if (dbg) {
-					printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s\n", def, val, name);
-					printf("mksymbol(): i: $%X, id: $%04X\n", i, s->id);
 				}
+			} else {
+				return s;
 			}
-			return s;
 		}
 	}
-	size_t str_size = strlen(name)+1;
-	s = malloc(sizeof(symbol));
-	s->down = NULL;
-	if (!islocal) {
-		(last_sym) ? (last_sym->next = s) : (symbols = s);
-		if (last_sym) {
-			last_sym->next->prev = last_sym;
-			last_sym->next->up = last_sym->up;
-			last_sym->next->down = NULL;
+	return NULL;
+}
+
+int add_symbol(symbol *sym, const char *name, symbol **root, symbol **lsym, symbol **rloc, symbol **lloc, symbol **csym, int csym_depth, int depth, uint8_t dbg) {
+	symbol *s = (!depth) ? ((*lsym) ? *lsym : *root): ((*lloc) ? *lloc : *rloc);
+	sym->next = NULL;
+	sym->up = NULL;
+	sym->down = NULL;
+	sym->prev = NULL;
+	if (depth && depth >= csym_depth) {
+		//s = *csym;
+		s = find_symbol(*root, name, depth-1, dbg);
+		depth -= (!csym_depth) ? depth-1 : csym_depth;
+	}
+	int j = 0;
+	int is_new_scope = 0;
+	for (int i = 0; i < depth; i++) {
+		if (s) {
+			if (s->down != NULL) {
+				s->down->up = (s->down->up == NULL) ? s : s->down->up;
+				s = s->down;
+			} else if (j) {
+				return 0;
+			} else {
+				int is_first_entry = ((s->up == NULL) || (s->next == NULL && s->up));
+				is_new_scope = (depth <= 1 && is_first_entry);
+				j++;
+			}
 		} else {
-			symbols->prev = NULL;
-			symbols->up = NULL;
-			symbols->down = NULL;
+			is_new_scope = 1;
+			/*return 0;*/
 		}
-	} else {
-		(last_loc) ? (last_loc->next = s) : (locals = s);
-		if (last_loc) {
-			last_loc->next->prev = last_loc;
-			last_loc->next->up = last_loc->up;
-			last_loc->next->down = NULL;
+	}
+		for (; s != NULL && s->next != NULL; s = s->next) {
+			if (dbg) {
+				printf("s: %p, s->next: %p, s->prev: %p\n", s, s->next, s->prev);
+			}
+		}
+	if ((is_new_scope && *lsym) || *lloc || *csym) {
+		/*
+		if (is_new_scope) {
+			s = *lsym;
 		} else {
-			locals->prev = NULL;
-			locals->down = NULL;
+			s = (!depth) ? *lsym : *lloc;
+		}*/
+		if (is_new_scope && sym->depth > s->depth) {
+			s->down = sym;
+			s->down->up = s;
+			s->down->prev = NULL;
+		} else {
+			s->next = sym;
+		}
+		if (dbg) {
+			for (symbol *tmp = s; tmp && tmp->prev; tmp = tmp->prev) {
+				printf("add_symbol(): s: %p, s->name: %s, s->next: %p, s->prev: %p, s->up: %p, s->down: %p\n", tmp, tmp->name, tmp->next, tmp->prev, tmp->up, tmp->down);
+			}
+		}
+		sym->next = NULL;
+		if (s->next == sym) {
+			sym->prev = s;
+			if (sym->depth) {
+				sym->up = s->up;
+			}
+		}
+		sym->down = NULL;
+
+	}
+
+	if ((*root && (*root)->prev)) {
+		(*root)->prev = NULL;
+	}
+
+	if ((*rloc && (*rloc)->prev)) {
+		(*rloc)->prev = NULL;
+	}
+	if (!depth) {
+		if (*lsym == NULL) {
+			*root = sym;
+			sym->next = NULL;
+			sym->prev = NULL;
+			sym->up = NULL;
+			sym->down = NULL;
+		}
+		*lsym = sym;
+		*rloc = NULL;
+		*lloc = NULL;
+	} else {
+		if (is_new_scope) {
+			*lloc = NULL;
+		}
+		if (*lloc == NULL) {
+			*rloc = sym;
+			sym->next = NULL;
+			sym->prev = NULL;
+			sym->down = NULL;
 		}
+		*lloc = sym;
 	}
+	*csym = sym;
+	return 1;
+}
+
+char *find_deepest_scope(const char *name) {
+	int i;
+	for (i = strlen(name); i >= 0 && name[i] != '.'; i--);
+	return (char *)name+(i+1);
+}
+
+symbol *mksymbol(const char *name, uint64_t val, uint8_t def, int depth, uint8_t use_scope, uint16_t id, uint8_t dbg) {
+	uint16_t i = 0;
+	symbol *s = find_symbol(symbols, (char *)name, depth, dbg);
+	char *scope_name = (!use_scope) ? find_deepest_scope(name) : (char *)name;
+	if (s) {
+		if (def) {
+			if (s->def) {
+				if (dbg) {
+					printf("mksymbol(): oof, you cannot redefine the symbol: %s\n", scope_name);
+				}
+				defined = 1;
+			} else {
+				defined = 0;
+			}
+			s->def = def;
+			s->val = val;
+			s->id = i;
+			if (dbg) {
+				printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s\n", def, val, scope_name);
+				printf("mksymbol(): i: $%X, id: $%04X\n", i, s->id);
+			}
+		}
+		return s;
+	}
+	size_t str_size = strlen(scope_name)+1;
+
+	s = malloc(sizeof(symbol));
 	s->name = malloc(str_size);
 	s->def = def;
 	s->val = val;
 	s->count = 0;
 	s->isstruct = 0;
-	memcpy(s->name, name, str_size);
+	s->depth = depth;
 	s->next = NULL;
+	s->up = NULL;
+	s->down = NULL;
+	s->prev = NULL;
 	s->id = sym_count++;
-	(!islocal) ? (last_sym = s) : (last_loc = s);
-	if (!islocal) {
-		s->down = NULL;
-		/*if (def) {
-			locals = NULL;
-			last_loc = NULL;
-		}*/
-	} else {
-		cur_sym->count++;
-	}
+
+	memcpy(s->name, scope_name, str_size);
 	defined = 0;
 	if (dbg) {
-		printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s, id: $%04X\n", def, val, name, sym_count-1);
+		printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s, id: $%04X\n", def, val, scope_name, sym_count-1);
 	}
 	return s;
 }
 
 uint16_t fixup_cnt = 0;
-symbol *get_sym(const char *name, uint64_t val, token *t, uint8_t islocal, uint8_t dbg) {
-	symbol *s = mksymbol(name, 0, 0, islocal, 0, 0, dbg);
+symbol *get_sym(const char *name, uint64_t val, token *t, uint8_t depth, uint8_t use_scope, uint8_t dbg) {
+	symbol *s = mksymbol(name, val, 0, depth, use_scope, use_scope, dbg);
 	if (dbg) {
 		printf("get_sym(): Symbol ID: $%X.\n", s->id);
 	}
-	if (s->def) {
-		return s;
-	} else {
+	if (!s->def) {
 		if (dbg) {
 			printf("get_sym(): oof, symbol %s, does not exist, yet.\n", name);
 		}
@@ -112,28 +208,8 @@ symbol *get_sym(const char *name, uint64_t val, token *t, uint8_t islocal, uint8
 		f->next = NULL;
 		last_fix = f;
 		fixup_cnt++;
-		return NULL;
 	}
-}
-
-symbol *find_member(char *name, symbol* root, uint8_t dbg) {
-	/*for (; root->up; root = root->up);*/
-	symbol *s = root;
-	if (s->down == NULL && s->up != NULL) {
-		s = s->up;
-	}
-	do {
-		s = s->down;
-		for (symbol *m = s; m; m = m->next) {
-			size_t len1 = strlen(name);
-			size_t len2 = strlen(m->name);
-			if (len1 == len2 && name[0] == m->name[0] && !strcmp(name, m->name)) {
-				return m;
-			}
-		}
-		for (;s && s->next && !s->down; s = s->next);
-	} while (s && s->down);
-	return NULL;
+	return s;
 }
 
 uint16_t reslv_fixups(uint8_t dbg) {
@@ -228,16 +304,62 @@ line *find_line(uint32_t ln, uint8_t dbg) {
 	return l;
 }
 
+char *mk_scope_name(symbol *csym, int depth, const char *name, uint8_t dbg) {
+	size_t len = strlen(name);
+	size_t name_len = len;
+	symbol *s = csym;
+	char **scopes;
+	if (depth) {
+		scopes = malloc(sizeof(char *)*depth);
+	}
+
+	for (int i = depth; i && s; i--) {
+		if (dbg) {
+			printf("mk_scope_name(): s->depth: %i\n", s->depth);
+		}
+		s = (s->depth >= i && s->up) ? s->up : s;
+		//s = (i < 2 && s->up) ? s->up : s;
+		len += strlen(s->name);
+		scopes[i-1] = s->name;
+	}
+
+	len += depth;
+	char *scope_name = malloc(len+1);
+	char *tmp = scope_name;
+	memset(tmp, 0, len+1);
+	for (int i = 0; i < depth; i++) {
+		size_t name_len = strlen(scopes[i]);
+		memcpy(tmp, scopes[i], name_len);
+		tmp += name_len;
+		*tmp++ = '.';
+		if (dbg) {
+			printf("mk_scope_name(): scope_name: %s\n", scope_name);
+		}
+	}
+	memcpy(tmp, name, name_len);
+	if (dbg) {
+		printf("mk_scope_name(): scope_name: %s\n", scope_name);
+	}
+	return scope_name;
+}
+
 int is_struct = 0;
 int is_anon = 0;
 
-void create_struct(symbol *c_sym, line *l, token *t, token *lt, char *name, uint8_t dbg) {
-	uint8_t ismember = !(is_struct == 1 && lt && lt->id == TOK_DIR);
-	mksymbol(name, 0, 1, ismember, 0, 0, dbg);
+void create_struct(symbol *c_sym, line *l, token *t, token *lt, const char *name, uint8_t dbg) {
+	int depth = is_struct-is_anon;
+	uint8_t ismember = !(depth == 1 && lt && lt->id == TOK_DIR);
+	int is_new_scope = (lt && lt->id == TOK_DIR);
+	depth -= is_new_scope;
+
+	char *struct_name = mk_scope_name(c_sym, depth, name, dbg);
+	symbol *s = mksymbol(struct_name, 0, 1, depth, 0, 0, dbg);
+	int is_sym_added = add_symbol(s, struct_name, &symbols, &last_sym, &locals, &last_loc, &c_sym, 0, depth, dbg);
+	t->sym = get_sym(struct_name, 0, t, depth, 0, dbg);
+
 	if (isfixup) {
 		isfixup = reslv_fixups(dbg);
 	}
-	t->sym = get_sym(name, 0, t, ismember, dbg);
 	if (lt && lt->id == TOK_DIR) {
 		t->sym->isstruct = 1;
 		t->id = (lt->type == DIR_STRUCT) ? TOK_STRUCT : TOK_UNION;
@@ -257,26 +379,24 @@ void create_struct(symbol *c_sym, line *l, token *t, token *lt, char *name, uint
 		} else {
 			c_sym->down = locals;
 		}
-	} else {
-		if (lt && lt->id == TOK_DIR) {
-			if (lt->type == DIR_UNION || lt->type == DIR_STRUCT) {
-				c_sym->down = locals;
-				c_sym->down->up = c_sym;
-				last_loc->up = c_sym;
-				c_sym = last_loc;
-				locals = NULL;
-				last_loc = NULL;
-			}
-		}
 	}
 	cur_sym = c_sym;
 }
 
 void end_struct(symbol *c_sym, symbol *s_sym, uint8_t dbg) {
 	int skip = 0;
-	if (/*s_sym &&*/ is_anon > 0) {
+	if (is_anon > 0) {
 		if ((c_sym && c_sym->isanon) || (c_sym->up && !c_sym->up->isanon) || (c_sym && s_sym->isanon)) {
-			is_anon--;
+			int depth = is_struct-is_anon;
+			if ((depth > 0 || (is_struct > 1 && is_anon >= is_struct)) && c_sym->depth > depth) {
+				for (; c_sym->depth > is_struct-is_anon && c_sym->up; c_sym = c_sym->up) {
+					if (dbg) {
+						printf("end_struct(): c_sym->depth: %i, is_struct-is_anon: %i\n", c_sym->depth, is_struct-is_anon);
+					}
+				}
+			} else if (c_sym->depth) {
+				is_anon--;
+			}
 		} else if (is_struct <= 0) {
 			is_anon = 0;
 		}
@@ -289,15 +409,21 @@ void end_struct(symbol *c_sym, symbol *s_sym, uint8_t dbg) {
 				s->up = c_sym;
 			}
 			if (dbg) {
-				printf("s: %p, s->up: %p, c_sym: %p, last_loc: %p\n", s, s->up, c_sym, last_loc);
+				printf("end_struct(): s: %p, s->up: %p, c_sym: %p, last_loc: %p\n", s, s->up, c_sym, last_loc);
 			}
 		}
-		if (c_sym->down == NULL) {
-			c_sym->down = locals;
-		}
 	}
 	if ((is_anon <= 0 || is_struct <= 0)) {
-		for (s_sym = c_sym; /*s_sym &&*/ s_sym->prev && !s_sym->isanon; s_sym = s_sym->prev);
+		if (dbg) {
+			for (symbol *s = c_sym; s->next && !s->isanon; s = s->next) {
+				printf("end_struct(): %p, s->next: %p, s->prev: %p, s->isanon: %i\n", s, s->next, s->prev, s->isanon);
+			}
+		}
+		for (s_sym = c_sym; s_sym->prev && !s_sym->isanon; s_sym = s_sym->prev) {
+			if (dbg) {
+				printf("end_struct(): s_sym: %p, s_sym->next: %p, s_sym->prev: %p, s_sym->isanon: %i\n", s_sym, s_sym->next, s_sym->prev, s_sym->isanon);
+			}
+		}
 		struct_sym = s_sym;
 	}
 	if ((is_struct-is_anon) > 0 && !skip) {
@@ -307,7 +433,7 @@ void end_struct(symbol *c_sym, symbol *s_sym, uint8_t dbg) {
 				s->up = c_sym->up;
 			}
 			if (dbg) {
-				printf("s: %p, s->up: %p, c_sym->up: %p, last_loc: %p\n", s, s->up, c_sym->up, last_loc);
+				printf("end_struct(): s: %p, s->up: %p, c_sym->up: %p, last_loc: %p\n", s, s->up, c_sym->up, last_loc);
 			}
 		}
 		if (c_sym->up) {
@@ -318,6 +444,74 @@ void end_struct(symbol *c_sym, symbol *s_sym, uint8_t dbg) {
 	}
 }
 
+fixup *find_fixup(fixup *root, const char *name, int depth, uint8_t dbg) {
+	size_t name_len = strlen(name);
+	for (fixup *f = root; f; f = f->next) {
+		symbol *s = f->s;
+		if (s && s->name) {
+			if (s->depth == depth) {
+				size_t sym_name_len = strlen(s->name);
+				if (name_len == sym_name_len && name[0] == s->name[0] && !strcmp(name, s->name)) {
+					if (!s->def) {
+						return f;
+					}
+				}
+			}
+		}
+	}
+	return NULL;
+}
+
+void resolve_symbol_names(line *l, const char *name, symbol *sym, int depth, uint8_t dbg) {
+	size_t name_len = strlen(name);
+	for (token *t = l->tok; t; t = t->next) {
+		size_t sym_name_len;
+		switch (t->id) {
+			case TOK_LABEL:
+			case TOK_SYM:
+				if (t->sym) {
+					sym_name_len = strlen(t->sym->name);
+					if (name_len == sym_name_len && name[0] == t->sym->name[0] && !strcmp(name, t->sym->name)) {
+						if (t->sym->depth == depth && !t->sym->def) {
+							t->sym = sym;
+						}
+					}
+				}
+				break;
+		}
+	}
+	if (l->next) {
+		resolve_symbol_names(l->next, name, sym, depth, dbg);
+	}
+}
+
+void new_symbol(token *t, const char *name, uint64_t value, int depth, uint8_t dbg) {
+	size_t name_len = strlen(name);
+	char *scope_name = mk_scope_name(cur_sym, depth, name, dbg);
+	symbol *s;
+	fixup *f = find_fixup(fixups, scope_name, depth, dbg);
+	if (f == NULL) {
+		s = mksymbol(scope_name, value, 1, depth, 0, 0, dbg);
+	} else {
+		s = f->s;
+		resolve_symbol_names(lines, scope_name, s, depth, dbg);
+		s->def = 1;
+		s->val = value;
+		free(s->name);
+		s->name = NULL;
+		s->name = malloc(name_len+1);
+		memcpy(s->name, name, name_len+1);
+	}
+	int is_sym_added = add_symbol(s, scope_name, &symbols, &last_sym, &locals, &last_loc, &cur_sym, 0, depth, dbg);
+	if (isfixup) {
+		isfixup = reslv_fixups(dbg);
+	}
+	if (t) {
+		t->sym = get_sym(scope_name, value, t, depth, 0, dbg);
+		isfixup += (t->sym == NULL);
+	}
+}
+
 uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 	char sym[0x100];
 	uint16_t i = 0;
@@ -337,7 +531,9 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 	uint8_t of = 0;
 	uint8_t base = 0;
 
-	uint8_t islocal = 0;
+	int depth = 0;
+
+	int is_inst = 0;
 
 	uint8_t isop = 0;
 	int num = 0;
@@ -355,13 +551,11 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 	uint8_t done = 0;
 
 
-	/*uint8_t is_newcom = 0;*/
 	line *l = NULL;
 	token *st = NULL;
 	token *t = NULL;
 	token *lt = NULL;
 	symbol *tmp_sym = NULL;
-	symbol *tsym = NULL;
 
 	while (isdigit(str[i]) && isdelm(str[i], dbg) != 16) {
 		lnum[j++] = str[i++];
@@ -412,6 +606,7 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 			if (((ptok == PTOK_S || ptok == PTOK_B) && toupper(str[i+1]) == 'P') || (ptok == PTOK_P && toupper(str[i+1]) == 'C')) {
 				offset++;
 			}
+			int is_alpha = 0;
 			switch (get_ptok(str[i+offset], dbg)) {
 				case PTOK_B	:
 				case PTOK_E	:
@@ -424,7 +619,7 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				case PTOK_D	:
 				case PTOK_F	:
 				case PTOK_R	:
-				case PTOK_ALPHA	: ptok = PTOK_ALPHA; break;
+				case PTOK_ALPHA	: ptok = PTOK_ALPHA; is_alpha = 1; break;
 				case PTOK_NUMBER:
 					if (ptok == PTOK_R) {
 						char reg_num[3];
@@ -435,20 +630,28 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 						reg_num[isnum] = '\0';
 						if (isnum == 2) {
 							int regnum = strtoul(reg_num, NULL, 10);
-							ptok = (regnum < 11 || regnum > 15) ? PTOK_ALPHA : ptok;
+							if (regnum < 11 || regnum > 15) {
+								ptok = PTOK_ALPHA;
+								is_alpha = 1;
+							}
 						} else {
 							ptok = PTOK_ALPHA;
+							is_alpha = 1;
 						}
 					} else {
 						ptok = PTOK_ALPHA;
+						is_alpha = 1;
 					}
 					break;
 			}
-			if ((ptok == PTOK_S && str[i+1] && toupper(str[i+1]) != 'P') || (ptok == PTOK_P && toupper(str[i+1]) != 'C')) {
+			if (ptok == PTOK_P && toupper(str[i+1]) != 'C') {
 				ptok = PTOK_ALPHA;
+				is_alpha = 1;
 			}
+
+			ptok = (!is_inst && !is_alpha) ? PTOK_ALPHA : ptok;
 		}
-		/*i = ptok_handler[ptok](str, i, lex_type, l, t, dbg);*/
+
 		switch (ptok) {
 			case PTOK_DOT:
 				i++;
@@ -463,9 +666,10 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 							uint16_t tmp = j;
 							for (j = 0; isdelm(str[i+j], dbg) & 16; j++);
 							uint8_t ret = get_ptok(str[i+j], dbg);
+							ret = (is_altok(ret, dbg)) ? PTOK_ALPHA : ret;
 							j = tmp;
 
-							if ((k == DIR_STRUCT || k == DIR_UNION) && (ret != PTOK_ALPHA || (is_anon && ret == PTOK_ALPHA))) {
+							if ((k == DIR_STRUCT || k == DIR_UNION) && ret != PTOK_ALPHA) {
 								is_anon++;
 							}
 							is_struct += (k == DIR_STRUCT || k == DIR_UNION);
@@ -556,16 +760,8 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				i += j;
 				value = strtoull(lexeme, NULL, base);
 				if (lt->id == TOK_SYM) {
-					tsym = mksymbol(sym, value, 1, islocal, 0, 0, dbg);
-					if (lt) {
-						lt->sym = get_sym(sym, address, lt, islocal, dbg);
-					}
-					if (!islocal) {
-						cur_sym = last_sym;
-					}
-					tsym = NULL;
-					islocal = 0;
-					isfixup += (lt->sym == NULL);
+					new_symbol(lt, sym, value, depth, dbg);
+					depth = 0;
 					if (dbg) {
 						printf("lex(): isfixup: %u\n", isfixup);
 					}
@@ -606,20 +802,17 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				break;
 			case PTOK_LBRACK:
 			case PTOK_HASH  :
-				/*l->tok->type = (ptok == PTOK_LBRACK) ? IND : IMM;
-				lex_type = (ptok == PTOK_LBRACK) ? TOK_IND : TOK_IMM;*/
 				lex_type = TOK_MEM;
 				value = (ptok == PTOK_LBRACK) ? MEM_IND : MEM_IMM;
 				l->count++;
 				t = make_token(lex_type, value, space, tab, 0, "", NULL);
 				lex_type = (ptok == PTOK_LBRACK) ? TOK_IND : TOK_IMM;
+				t->subtype = (t->subtype == 0xFF && lex_subtype != 0xFF) ? lex_subtype : t->subtype;
 				if (lex_subtype != 0xFF) {
 					lex_subtype = 0xFF;
 				}
 				memset(lexeme, 0, strlen(lexeme)+1);
 				lexeme[j++] = str[i];
-				/*(t) ? (t->subspace = space) : (lt->subspace = space);
-				(t) ? (t->subtab = tab) : (lt->subtab = tab);*/
 				break;
 			case PTOK_PLUS:
 			case PTOK_MINUS:
@@ -695,7 +888,6 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				lexeme[j+1] = (ptok == PTOK_R || ((ptok == PTOK_S || ptok == PTOK_B) && get_ptok(str[i], dbg) == PTOK_P)) ? str[i++] : '\0';
 				lexeme[j+2] = (ptok == PTOK_R) ? str[i++] : '\0';
 				lexeme[j+3] = '\0';
-				/*lex_subtype = (lex_type == TOK_CSV && lt && lt->subtype != TOK_CSV) ? lex_type : lex_subtype;*/
 				lex_type = TOK_REG;
 				switch (ptok) {
 					case PTOK_A: value = REG_A; break;
@@ -719,17 +911,11 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				t = make_token(lex_type, value, space, tab, 0, "", NULL);
 				t->subtype = (t->subtype == 0xFF && lex_subtype != 0xFF) ? lex_subtype : t->subtype;
 				lex_subtype = 0xFF;
-				/*(t) ? (t->subspace = space) : (lt->subspace = space);
-				(t) ? (t->subtab = tab) : (lt->subtab = tab);*/
 				break;
 			case PTOK_P:
 				lexeme[j] = str[i++];
 				lexeme[j+1] = (str[i] != ',') ? str[i++] : '\0';
 				lexeme[j+2] = '\0';
-				/*switch (ptok) {
-					case PTOK_S: of = 1; break;
-					case PTOK_P: of = 2; break;
-				}*/
 				of = 2;
 				lex_type = TOK_OF;
 				l->count++;
@@ -737,8 +923,8 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				break;
 			case PTOK_AT:
 				memset(lexeme, 0, strlen(lexeme)+1);
+				for (char *tmp = str+i; *tmp++ == '@'; depth++);
 				lexeme[j] = '@';
-				islocal = 1;
 				lex_type = TOK_LOCAL;
 				if (lt || t) {
 					(t) ? (t->subspace = space) : (lt->subspace = space);
@@ -750,26 +936,12 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 				lexeme[j] = ':';
 				lexeme[j+1] = '\0';
 				lex_type = TOK_LABEL;
-				tsym = mksymbol(sym, address, 1, islocal, 0, 0, dbg);
-				if (isfixup) {
-					isfixup = reslv_fixups(dbg);
-				}
 				if (lt) {
 					lt->id   = lex_type;
-					lt->type = islocal;
-					lt->sym  = get_sym(sym, address, t, islocal, dbg);
-					isfixup += (lt->sym == NULL);
-				}
-                                if (!islocal) {
-                                        cur_sym = last_sym;
-					locals = NULL;
-			        	last_loc = NULL;
-				} else if (cur_sym->down == NULL && cur_sym == last_sym) {
-			               cur_sym->down = locals;
-			               cur_sym->down->up = cur_sym;
+					lt->type = depth;
 				}
-				tsym = NULL;
-				islocal = 0;
+				new_symbol(lt, sym, address, depth, dbg);
+				depth = 0;
 				if (dbg) {
 					printf("lex(): isfixup: %u\n", isfixup);
 				}
@@ -812,7 +984,7 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 
 				break;
 			case PTOK_ALPHA:
-				for (; !isdelm2(str[i+j], dbg); j++);
+				for (; !isdelm2(str[i+j], dbg) || (is_inst && str[i+j] == '.'); j++);
 				memcpy(lexeme, str+i, j);
 				lexeme[j] = '\0';
 				i += j;
@@ -836,6 +1008,7 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 								lex_type = (is_ext) ? TOK_EXTOP : lex_type;
 								lex_type = (is_ortho) ? TOK_ORTHO : lex_type;
 								isop = 1;
+								is_inst = 1;
 								l->count++;
 								t = make_token(lex_type, 0xFF, space, tab, k, "", NULL);
 								break;
@@ -860,37 +1033,34 @@ uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) {
 						for (; isdelm(str[i+spaces], dbg) == 16; spaces++);
 						uint8_t ret = get_ptok(str[i+spaces], dbg);
 						if (ret == PTOK_COLON || ret == PTOK_EQU) {
-							islocal = (lex_type == TOK_LOCAL);
+							depth = (lex_type == TOK_LOCAL);
 						}
 						lex_type = TOK_SYM;
 						l->count++;
-						t = make_token(lex_type, islocal, space, tab, 0, "", NULL);
+						t = make_token(lex_type, depth, space, tab, 0, "", NULL);
 						memcpy(sym, lexeme, j+1);
 						if (dbg) {
 							printf("lex(): spaces: %u\n", spaces);
 						}
 						if (is_struct) {
 							create_struct(cur_sym, l, t, lt, sym, dbg);
-							islocal = 0;
+							depth = 0;
 						} else if ((str[i+spaces] != ':' && str[i+spaces] != '=')) {
-							uint8_t sym_struct = 0;
 							symbol *s;
-							/*tmp_sym = (s && s->isstruct) ? NULL : tmp_sym;*/
-							if (tmp_sym) {
-								t->sym = find_member(lexeme, tmp_sym, dbg);
-								tmp_sym = NULL;
-							} else {
-								t->sym = get_sym(lexeme, address, t, islocal, dbg);
-							}
+							int scope_depth;
+							char *tmp = lexeme;
+							for (scope_depth = 0; *tmp; scope_depth += (*tmp++ == '.'));
+							char *scope_name = (!scope_depth) ? mk_scope_name(cur_sym, depth, lexeme, dbg) : lexeme;
+							t->sym = get_sym(scope_name, address, t, (scope_depth) ? scope_depth : depth, 1, dbg);
 							isfixup += (t && t->sym == NULL);
-							islocal = 0;
+							depth = 0;
 							if (dbg) {
 								printf("lex(): isfixup: %u\n", isfixup);
 							}
 						}
-						if (!is_struct && t && t->sym && t->sym->isstruct) {
+						/*if (!is_struct && t && t->sym && t->sym->isstruct) {
 							tmp_sym = t->sym;
-						}
+						}*/
 					}
 				}
 				break;
diff --git a/programs/sub-suite/declare.s b/programs/sub-suite/declare.s
index 550228d..36a4f15 100644
--- a/programs/sub-suite/declare.s
+++ b/programs/sub-suite/declare.s
@@ -2,7 +2,7 @@
 ; Structs, and unions.
 
 ; Line struct.
-.struct ln
+.struct line
 	next	.qword	; Pointer to next line.
 	tok	.qword	; The tokens for this line.
 
@@ -852,7 +852,7 @@ cmd_srt:
 	.word list
 	.word asm
 	.word help
-	.word inst
+	.word instruction
 	.word run
 	.word set_val
 
diff --git a/programs/sub-suite/free-new.s b/programs/sub-suite/free-new.s
new file mode 100644
index 0000000..dad19d0
--- /dev/null
+++ b/programs/sub-suite/free-new.s
@@ -0,0 +1,143 @@
+.include "declare.s"
+
+.org 0
+
+; free: Free allocated memory.
+; Input: D = Pointer to allocated memory.
+; Output: none.
+; Caller preserved registers: D.
+; Callie preserved registers: A, B, X, Y, E.
+
+free:
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	phe.q			; Preserve E.
+	and #0			; Reset A.
+	tab			; Reset B.
+	tax			; Reset X.
+	tay			; Reset Y.
+	mov a, d		; Get the passed pointer.
+	bne @getrealblk		; The pointer isn't NULL, so get the real block.
+	bra @end		; The pointer is NULL, so we're done.
+@getrealblk:
+	sub #8			; Get the start of the used block.
+	mov.q a, (a)		; Get the start of the real block.
+	mov.q b, (a+ublk.size)	; Get the size of the real block.
+	lea e, (a+b)		; Add the size of the real block with the start of the real block.
+	cmp.q e, heapptr	; Is this block on top of the heap?
+	bne @heapadd		; No, so add it to the free block list.
+@dectop:
+	mov.q heapptr, (a)	; Set the top of the heap to the start of the previous real block.
+@chklastblk:
+	mov.q b, heapl		; Get the last free list entry.
+	beq @end		; The free list is empty, so we're done.
+	ldy #fblk.size		; Get the size of the block.
+	mov.q a, (b+fblk.size)	; Get the size of the block.
+	lea e, (a+b)		; Add the size of the block, with the address of the block entry.
+	cmp.q e, heapptr	; Is the last block on top of the heap?
+	bne @end		; No, so we're done.
+@delblk:
+	mov.q heapptr, b	; Yes, so remove the last block.
+@correctblk:
+	mov.q a, (b+fblk.prev)	; Get the previous block.
+	sta.q heapl		; Set the last block to the previous block.
+	bne @delnxtblk		; The previous block isn't NULL, so delete the next block.
+	sta.q heapf		; The previous block is NULL, so empty the free list.
+	bra @end		; We are done.
+@delnxtblk:
+	lea e, (a+fblk.next)	; Delete the next block.
+	stz.q (e)		;
+@end:
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
+
+
+@heapadd:
+	mov.q y, heapf		; Get the first block.
+	bne @srchflst		; The Free list isn't empty, so start searching the free list.
+@empty:
+	mov.q (a+fblk.next), y	; Clear the next block.
+	mov.q (a+fblk.prev), y	; Clear the previous block.
+	sta.q heapf		; Set the first block entry to the current block.
+	sta.q heapl		; Set the last block entry to the current block.
+	bra @end		; We are done.
+@srchflst:
+@loop:
+	cmp y, a		; Is the right pointer at, or below the current block?
+	beq @nextright		; Yes, so get the next right pointer.
+	bcs @chkrmerge		; No, so do the right block merge.
+@nextright:
+	tyx			; Set the left pointer, to the right pointer.
+	mov.q y, (y+fblk.next)	; Set the current right pointer to the next right pointer.
+	bne @loop		; The next right pointer isn't NULL, so keep looping.
+@st_lmerge2:
+	mov.q (a+fblk.next), y	; Clear the next block.
+	sta.q heapl		; Set the last free block entry to it.
+	bra @chklmerge2		; Do the left block merge.
+@chkrmerge:
+	lea e, (a+b)		; Add the size of the current block, to the current block.
+	cmp e, y		; Is the current block the same as the right block?
+	bne @normerge		; No, so don't merge the right block.
+@rmerge:
+	mov e, b		; Get the size of the current block.
+	add.q e, (y+fblk.size)	; Add the size of the current block, with the size of the right pointer.
+	mov.q (a+fblk.size), e	; Set the size of the current block, to the new size.
+@rmerge2:
+	lea fblk.next		; Get the next right pointer.
+	mov.q (a+e), (y+e)	; Set the next block, to the next right pointer.
+	mov.q b, (y+e)		; Save the next block.
+	beq @setheapl		; The next block is NULL, so set the last block.
+@setprev:
+	mov.q (b+fblk.prev), a	; Set the previous block to the current block.
+	bra @chklmerge		; Do the left block merge.
+@setheapl:
+	sta.q heapl		; Set the last block to the current block.
+	bra @chklmerge		; Do the left block merge.
+@normerge:
+	mov.q (a+fblk.next), y	; Set the next block to the right pointer.
+	mov.q (y+fblk.prev), a	; Set the previous right pointer to the current block.
+@chklmerge:
+	and x, x		; Is the left pointer NULL?
+	bne @chklmerge2		; No, so keep checking.
+@newstart:
+	mov.q (a+fblk.prev), x	;
+	sta.q heapf		; Set the first block, to the current block.
+	bra @end2		; We are done.
+@chklmerge2:
+	mov.q e, (x+fblk.size)	; Get the size of the left block.
+	add e, x		; Add the size of the left block, to the left pointer.
+	cmp e, a		; Is the left block adjacent?
+	bne @nolmerge		; No, so don't merge the left block.
+@lmerge:
+	lea fblk.size		; Set the offset to the block size.
+	add.q (x+e), (a+e)	; Add the size of the left block, with the size of the current block.
+@lmerge2:
+	lea fblk.next		; Set the offset to the next block.
+	mov.q (x+e), (a+e)	; Set the next left pointer, to the next block.
+	mov.q b, (a+e)		; Get the next block.
+	beq @newlast		; The next block is NULL, so set the last block.
+@lprev:
+	mov.q (b+fblk.prev), x	; Set the next left pointer's previous pointer to the left pointer.
+	bra @end2		; We are done.
+@newlast:
+	stx.q heapl		; Set the last block, to the left pointer.
+	bra @end2		; We are done.
+@nolmerge:
+	mov.q (x+fblk.next), a	; Set the next left pointer, to the current block.
+@nolmerge2:
+	mov.q (a+fblk.prev), x	; Set the previous block, to the left pointer.
+@end2:
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
+
+a
+q
diff --git a/programs/sub-suite/free-old.s b/programs/sub-suite/free-old.s
new file mode 100644
index 0000000..7f75edd
--- /dev/null
+++ b/programs/sub-suite/free-old.s
@@ -0,0 +1,200 @@
+.include "declare.s"
+
+.org 0
+
+; free: Free allocated memory.
+; Input: A = Pointer to allocated memory.
+; Output: none.
+; Caller preserved registers: none.
+; Callie preserved registers: A, B, Y.
+
+free:
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
+	phy.q		; Preserve Y.
+	pha.q		; Push the pointer argument to the stack.
+	and #0		; Reset A.
+	tay		; Reset Y.
+	sbs #$18	; Allocate 3 local variables onto the stack.
+	lda.q sp+25	; Get the passed pointer.
+	ora.d sp+29	; Is the passed pointer NULL?
+	bne @getrealblk	; No, so get the real block.
+	bra @end	; Yes, so we're done.
+@getrealblk:
+	lda.q sp+25	; Get the passed pointer.
+	sec		; Prepare for a non borrowing subtract.
+	sbc #8		; Move the passed pointer back by one.
+	sta.q sp+25	; Set the first local variable to the start of the used block.
+	lda.q (sp+25)	; Get the real block address.
+	sta.q sp+25	; Set the passed pointer to the start of the real block.
+	ldy #ublk.size	; Get the size of the real block.
+	lda.q (sp+25), y;
+	sta.q sp+17	; Save the size of the real block.
+	clc		; Prepare for a non carrying add.
+	adc.q sp+25	; Add the size of the real block with the start of the real block.
+	cmp.q heapptr	; Is this block on top of the heap?
+	bne @heapadd	; No, so add it to the free block list.
+@dectop:
+	lda.q sp+25	; Get the block.
+	sta.q heapptr	; Set the top of the heap to it.
+@chklastblk:
+	lda.q heapl	; Get the last free list entry.
+	sta.q sp+17	; Copy it into the second local variable.
+	ora.d sp+21	; Is the free list empty?
+	beq @end	; Yes, so we're done.
+	lda.q sp+17	; No, so Get the last free list entry.
+	ldy #fblk.size	; Get the size of the block.
+	lda.q (sp+17), y;
+	clc		; Prepare for a non carrying add.
+	adc.q sp+17	; Add the size of the block, with the address of the block entry.
+	cmp.q heapptr	; Is the last block on top of the heap?
+	bne @end	; No, so we're done.
+@delblk:
+	lda.q sp+17	; Yes, so remove the last block.
+	sta.q heapptr	;
+@correctblk:
+	ldy #fblk.prev	; Get the previous block.
+	lda.q (sp+17), y;
+	sta.q sp+25	; Save the previous block for now.
+	sta.q heapl	; Set the last block to the previous block.
+	ora.d sp+29	; Is the previous block non NULL?
+	bne @delnxtblk	; Yes, so delete the next block.
+	sta.q heapf	; No, so empty the free list.
+	bra @end	; We are done.
+@delnxtblk:
+	and #0		; Reset A.
+	ldy #fblk.next	; Delete the next block.
+	sta.q (sp+25), y;
+@end:
+	ads #$20	; Clean up the stack frame.
+	ply.q		; Restore Y.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of free.
+
+
+@heapadd:
+	lda.q heapf	; Get the first block.
+	sta.q sp+9	; Copy it into the third local variable.
+	ora.d sp+13	; Is the free list empty?
+	bne @srchflst	; No, so start searching the free list.
+@empty:
+	ldy #fblk.next	; Clear the next block.
+	sta.q (sp+25), y;
+	ldy #fblk.prev	; Clear the previous block.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Reset A.
+	sta.q heapf	; Clear the first block entry.
+	sta.q heapf	; Clear the last block entry.
+	bra @end	; We are done.
+@srchflst:
+	and #0		; Reset A.
+	sta.q sp+1	; Reset the left pointer.
+	ldy #fblk.next	; Setup for the loop.
+@loop:
+	lda.q sp+9	; Get the right pointer.
+	cmp.q sp+25	; Is the right pointer at, or below the current block?
+	beq @nextright	; Yes, so get the next right pointer.
+	bcs @chkrmerge	; No, so do the right block merge.
+@nextright:
+	sta.q sp+1	; Set the left pointer, to the right pointer.
+	lda.q (sp+9), y	; Get the next right pointer.
+	sta.q sp+9	; Set the current right pointer to the next right pointer.
+	ora.d sp+13	; Is the next right pointer NULL?
+	bne @loop	; No, so keep looping.
+@st_lmerge2:
+	sta.q (sp+25), y; Clear the next block.
+	lda.q sp+25	; Get the current block.
+	sta.q heapl	; Set the last free block entry to it.
+	bra @chklmerge2	; Do the left block merge.
+@chkrmerge:
+	lda.q sp+25	; Get the current block.
+	clc		; Prepare for a non carrying add.
+	adc.q sp+17	; Add the size of the current block, to the current block.
+	cmp.q sp+9	; Is the right pointer NULL?
+	bne @normerge	; No, so don't merge the right block.
+@rmerge:
+	ldy #fblk.size	; Get the size of the right pointer.
+	lda.q sp+17	; Get the size of the current block.
+	clc		; Prepare for a non carrying add.
+	adc.q (sp+9), y	; Add the size of the current block, with the size of the right pointer.
+	sta.q (sp+25), y; Set the size of the current block, to the new size.
+@rmerge2:
+	ldy #fblk.next	; Get the next right pointer.
+	lda.q (sp+9), y	;
+	sta.q (sp+25), y; Set the next block, to the next right pointer.
+	sta.q sp+17	; Save the next block in the second local variable.
+	ora.d sp+21	; Is the next block NULL?
+	beq @setheapl	; Yes, so set the last block.
+@setprev:
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.prev	; Set the previous block to the current block.
+	sta.q (sp+17), y;
+	bra @chklmerge	; Do the left block merge.
+@setheapl:
+	lda.q sp+25	; Get the current block.
+	sta.q heapl	; Set the last block to the current block.
+	bra @chklmerge	; Do the left block merge.
+@normerge:
+	lda.q sp+9	; Get the right pointer.
+	ldy #fblk.next	; Set the next block to the right pointer.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.prev	; Set the previous right pointer to the current block.
+	lda.q (sp+9), y	;
+@chklmerge:
+	lda.q sp+1	; Get the left pointer.
+	ora.d sp+5	; Is the left pointer NULL?
+	bne @chklmerge2	; No, so keep checking.
+@newstart:
+	ldy #fblk.prev	; Clear the previous block.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Get the current block.
+	sta.q heapf	; Set the first block, to the current block.
+	bra @end2	; We are done.
+@chklmerge2:
+	ldy #fblk.size	; Get the size of the left block.
+	lda.q (sp+1), y	;
+	clc		; Prepare for a non carrying add.
+	adc.q sp+1	; Add the size of the left block, to the left pointer.
+	cmp.q sp+25	; Is the left block adjacent?
+	bne @nolmerge	; No, so don't merge the left block.
+@lmerge:
+	lda.q (sp+1), y	; Get the size of the left block.
+	clc		; Prepare for a non carrying add.
+	ldb.q (sp+25), y; Get the size of the current block.
+	adc b		; Add the size of the left block, with the size of the current block.
+	sta.q (sp+1), y	; Set the size of the left block to the new size.
+@lmerge2:
+	ldy #fblk.next	; Get the next block.
+	lda.q (sp+25), y;
+	sta.q (sp+1), y	; Set the next left pointer, to the next block.
+	sta.q sp+17	; Set the second local variable to the next block.
+	ora.d sp+21	; Is the next left pointer NULL?
+	beq @newlast	; Yes, so set the last block.
+@lprev:
+	lda.q sp+1	; Get the left pointer.
+	ldy #fblk.prev	; Set the next left pointer's previous pointer to the left pointer.
+	sta.q (sp+17), y;
+	bra @end2	; We are done.
+@newlast:
+	lda.q sp+1	; Get the left pointer.
+	sta.q heapl	; Set the last block, to the left pointer.
+	bra @end2	; We are done.
+@nolmerge:
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.next	; Set the next left pointer, to the current block.
+	sta.q (sp+1), y	;
+@nolmerge2:
+	lda.q sp+1	; Get the left pointer.
+	ldy #fblk.prev	; Set the previous block, to the left pointer.
+	sta.q (sp+25), y;
+@end2:
+	ads #$20	; Clean up the stack frame.
+	ply.q		; Restore Y.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of free.
+
+a
+q
diff --git a/programs/sub-suite/lexer.s b/programs/sub-suite/lexer.s
index b2850aa..0d712ff 100644
--- a/programs/sub-suite/lexer.s
+++ b/programs/sub-suite/lexer.s
@@ -65,7 +65,7 @@ lex:
 ;@nextlline:
 ;	ldb #1		; No, so set the second pointer to the last line.
 ;	jsr set_ptr	;
-;	ldy #ln.next	; Set the next last line to the current line.
+;	ldy #line.next	; Set the next last line to the current line.
 ;	lda.q cline	;
 ;	sta.q (ptr2), y	;
 ;	bra @initline	; Initialize the line.
@@ -76,11 +76,11 @@ lex:
 ;	ldb #1		; Set the second pointer to the current line.
 ;	jsr set_ptr	;
 ;	and #0		; Reset A.
-;	ldy #ln.next	; Reset the next line.
+;	ldy #line.next	; Reset the next line.
 ;	sta.q (ptr2), y	;
-;	ldy #ln.tok	; Reset the token.
+;	ldy #line.tok	; Reset the token.
 ;	sta.q (ptr2), y	;
-;	ldy #ln.bline	; Reset the number of blank lines.
+;	ldy #line.bline	; Reset the number of blank lines.
 ;	sta.w (ptr2), y	;
 ;	tay		; Reset Y.
 @loop:
@@ -225,11 +225,10 @@ ptok_dot:
 	beq @found	; Yes, so create a new token.
 	inc idx1	; No, so increment the directive ID.
 @getlen:
+	mov d, a	; Get the string.
 	jsr strlen	; Get the string's length.
 	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx2	; Add the string offset to the current length
-	sta.w idx2	; Save the offset in the third index.
+	add.w idx2, a	; Add the string offset to the current length
 	bra @dir_loop	; Keep looping.
 @found:
 	lda #TOK_DIR	; Set the lexeme type to TOK_DIR.
@@ -443,11 +442,10 @@ ptok_alph:
 	beq @found	; Yes, so create a new token.
 	inc idx1	; No, so increment the instruction ID.
 @offset:
+	mov d, a	; Get the string.
 	jsr strlen	; Get the string's length.
 	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx2	; Add the string offset to the current length
-	sta.w idx2	; Save the offset in the third index.
+	add.w idx2, a	; Add the string offset to the current length
 	bra @isop_loop	; Keep looping.
 @found:
 	lda #TOK_MNE	; Set the lexeme type to TOK_MNE.
diff --git a/programs/sub-suite/libc.s b/programs/sub-suite/libc.s
index ae35146..53e936a 100644
--- a/programs/sub-suite/libc.s
+++ b/programs/sub-suite/libc.s
@@ -17,12 +17,10 @@ strtoull:
 	pla		; Get the character back.
 	beq @end	; No, so we're done.
 @alpha:
-	sec		; Yes, so prepare for a non borrowing subtract.
-	sbc #'a'-10	; Get the numeric value from this digit.
+	sub #'a'-10	; Yes, so get the numeric value from this digit.
 	bra @chkbase	; Check if the value matches the base.
 @digit:
-	sec		; Prepare for a non borrowing subtract.
-	sbc #'0'	; Get the numeric value from this digit.
+	sub #'0'	; Get the numeric value from this digit.
 @chkbase:
 	cmp sp+25	; Does the value match the base?
 	bcs @end	; No, so we're done.
@@ -30,8 +28,7 @@ strtoull:
 	tab		; Save the digit value.
 	lda.q sp+1	; Get the value from the value buffer.
 	mul sp+25	; Multiply the value by the base.
-	clc		; Prepare for a non carrying add.
-	adc b		; Add the digit value to the total value.
+	add a, b	; Add the digit value to the total value.
 	sta.q sp+1	; Place the value in the value buffer.
 	iny		; Increment the string index.
 	and #0		; Reset A.
@@ -44,80 +41,72 @@ strtoull:
 
 
 strlen:
-	phy.q		; Preserve Y.
-	pha.q		; Set the temp variable to the argument.
 	and #0		; Reset A.
-	tay		; Reset Y.
 @loop:
-	lda (sp+1), y	; Are we at the end of the string?
-	beq @end	; Yes, so we're done.
-	iny		; No, so increment the index.
-	bra @loop	; Keep looping.
+	inc		; Increment the index.
+	cmp (d+a-1), #0	; Are we at the end of the string?
+	bne @loop	; No, so keep looping.
 @end:
-	pla.q		; Get the argument back.
-	tya		; Get the return value.
-	ply.q		; Get the preserved value back.
+	dec		; Decrement the length to not include the terminator.
 	rts		; End of strlen.
 
 
 strcmp:
-	ldb #0		; Reset B.
-	tba		; Reset A.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phy.q		; Preserve Y.
+	and #0		; Reset A.
+	tab		; Reset B.
+	tax		; Reset X.
 	tay		; Reset Y.
 @loop:
-	ldb #0		; Set the islong flag to false.
-	lda (sp+25), y	; Are we at the end of the first string?
+	ldx #0		; Set the islong flag to false.
+	mov a, (d+y)	; Are we at the end of the first string?
 	beq cmpr	; Yes, so check if we're too short, or too long.
-	ldb #1		; No, so set the islong flag to true.
-	cmp (sp+19), y	; Is the character of both strings, the same?
+	ldx #1		; No, so set the islong flag to true.
+	cmp a, (s+y)	; Is the character of both strings, the same?
 	bne cmpr	; No, so check if we're too short, or too long.
 	iny		; Yes, so increment the index.
 	bra @loop	; Keep looping.
 
-strccmp:
 strcasecmp:
-	ldb #0		; Reset B.
-	tba		; Reset A.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phy.q		; Preserve Y.
+	and #0		; Reset A.
+	tab		; Reset B.
+	tax		; Reset X.
+	inx		; Set X to 1.
 	tay		; Reset Y.
 @loop:
-	ldb #0		; Set the islong flag to false.
-	lda (sp+25), y	; Are we at the end of the first string?
+	dex		; Set the islong flag to false.
+	mov a, (d+y)	; Are we at the end of the first string?
 	beq cmpr	; Yes, so check if we're too short, or too long.
-	ldb #1		; No, so set the islong flag to true.
+	inx		; No, so set the islong flag to true.
 	jsr tolower	; Convert the character of string 1 to lowercase.
-	phb		; Preserve the islong flag.
-	pha		; Preserve the converted character.
-	lda (sp+19), y	; Get the character of the second string.
+	tab		; Save the converted character.
+	mov a, (s+y)	; Get the character of the second string.
 	jsr tolower	; Convert the character of string 2 to lowercase.
-	tab		; Place it in B.
-	pla		; Get the character of string 1 back.
 	cmp b		; Is the character of both strings, the same?
-	plb		; Get the islong flag back.
 	bne cmpr	; No, so check if we're too short, or too long.
 	iny		; Yes, so increment the index.
 	bra @loop	; Keep looping.
 
 cmpr:
-	lda (sp+17), y	; Are we at the end of the second string?
+	mov a, (s+y)	; Are we at the end of the second string?
 	beq @islong	; Yes, so check the islong flag.
 @isshort:
-	lda (sp+25), y	; No, but are we at the end of the first string?
-	beq @short	; Yes, so return -1.
-@islong:
-	cpb #1		; Is the islong flag true?
-	bne @equ	; No, so return 0.
-@long:
-	lda #1		; Yes, so return 1.
+	mov a, (d+y)	; No, but are we at the end of the first string?
+	bne @islong	; No, so check if the islong flag is true.
+	lda #$FF	; Yes, so return -1.
 	bra @end	; We are done.
-@equ:
-	lda #0		; Return 0.
-	bra @end	; We are done.
-@short:
-	lda #$FF	; Return -1.
+@islong:
+	cpx #1		; Is the islong flag true?
+	set a, eq	; Return true if it is.
 @end:
-	ply.q		; Get the preserved value back.
+	ply.q		; Restore Y.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts		; End of cmpr.
 
 
@@ -195,304 +184,226 @@ toupper:
 
 
 ; malloc: Dynamically allocate memory.
-; Input: A = size in bytes to allocate.
+; Input: D = size in bytes to allocate.
 ; Output: A = Pointer to allocated memory.
-; Caller preserved registers: none.
-; Callie preserved registers: Y.
+; Caller preserved registers: D.
+; Callie preserved registers: B, X, Y.
 
 malloc:
-	phy.q		; Preserve Y.
-	pha.q		; Preserve the size.
-	and #0		; Reset A.
-	tay		; Reset Y.
-	sbs #$10	; Allocate 2 local variables onto the stack.
-	lda.q sp+17	; Get the size.
-	ora.d sp+21	; Is the size zero?
-	beq @end	; Yes, so we're done.
-	lda.q sp+17	; No, so get back the size.
-	clc		; Prepare for a non carrying add.
-	adc #ublk	; Add the size of a used block struct, to the size.
-	sta.q sp+17	; Set the actual size.
-	lda.q heapf	; Get the first heap entry.
-	sta.q sp+9	; Save it in the second local variable.
-	bra @checkblk	; Check the block.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	xor b, b		; Reset B.
+	mov x, b		; Reset X.
+	txy			; Reset Y.
+	mov a, d		; Get the size.
+	beq @end		; The size is zero, so we're done.
+	add #ublk		; Add the size of a used block struct, to the size.
+	cmp #ublk		; Is the total size smaller than the size of a used block struct?
+	bcs @getheapf		; No, so get the first heap entry.
+@toosmall:
+	lda #ublk		; Yes, so set the total size to the size of a used block struct.
+@getheapf:
+	mov d, a		; Place the new size into the passed size.
+	ldb.q heapf		; Get the first heap entry.
+	bra @checkblk		; Check the block.
 @findfblk:
-	ldy #fblk.size	; Get the size of this free block.
-	lda.q (sp+9), y	;
-	sec		; Prepare for a non borrowing subtract.
-	sbc.q sp+17	; Subtract the size of this free block, with the passed size.
-	bcs @blkfound	; The result is less than, or equal to the free size, so return the found block.
-	ldy #fblk.next	; Get the next free block.
-	lda.q (sp+9), y	;
-	sta.q sp+9	; Set the current free block, to the next free block.
+	mov.q a, (b+fblk.size)	; Get the size of this free block.
+	sub a, d		; Subtract the size of this free block, with the passed size.
+	bcs @blkfound		; The result is less than, or equal to the free size, so return the found block.
+	mov.q b, (b+fblk.next)	; Set the current free block, to the next free block.
 @checkblk:
-	ora.d sp+13	; Is the address of this block, zero?
-	bne @findfblk	; No, so keep looping.
-	lda.q heapptr	; Yes, so get the current top of the heap.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the top of the heap, with the passed size.
-	bcs @outofspace	; The result overflowed, so return zero.
-	cmp.q heapend	; Is the top of the heap, less than, or equal to the max heap size?
-	bcc @inctop	; Yes, so increase the current top of the heap.
-	beq @inctop	;
+	bne @findfblk		; The address of this block is non NULL, so keep looping.
+	mov a, d		; Get the passed size.
+	add.q heapptr		; Add the top of the heap, with the passed size.
+;	mov d, a		; Save the new size.
+	bcs @outofspace		; The result overflowed, so return zero.
+	cmp.q heapend		; Is the top of the heap, less than, or equal to the max heap size?
+	bcc @inctop		; Yes, so increase the current top of the heap.
+	beq @inctop		;
 @outofspace:
-	and #0		; Return zero.
-	bra @end	; We are done.
+	and #0			; Return zero.
+	bra @end		; We are done.
 @inctop:
-	pha.q		; Preserve heapptr + size.
-	lda.q heapptr	; Get the previous top of the heap.
-	sta.q sp+17	; Set the current free block to the previous top of the heap.
-	pla.q		; Restore heapptr + size.
-	sta.q heapptr	; Increment the current top of the heap by the passed size.
-	bra @setsize	; Set the size, and start address into the used space of the block.
+
+	ldb.q heapptr		; Set the current free block to the previous top of the heap.
+	sta.q heapptr		; Increment the current top of the heap by the passed size.
+	bra @setsize		; Set the size, and start address into the used space of the block.
 @blkfound:
-	bne @sliceblk	; The block is big enough to slice.
-	cmp #fblk	; Is the block big enough to slice?
-	bcs @sliceblk	; Yes, so slice the block.
-	ldy #fblk.prev	; No, so get the previous free block.
-	lda.q (sp+9), y	;
-	sta.q sp+1	; Set the third local variable, to the previous free block.
-	ora.d sp+5	; Is the previous block, set to zero?
-	beq @setheapf	; Yes, so set the first block.
-	ldy #fblk.next	; No, so get the next free block.
-	lda.q (sp+9), y	;
-	sta.q (sp+1), y	; Set the previous block's next block, to the next block.
-	bra @chknxtblk	; Check the next block.
+	bne @sliceblk		; The block is big enough to slice.
+	cmp #fblk		; Is the block big enough to slice?
+	bcs @sliceblk		; Yes, so slice the block.
+	mov.q x, (b+fblk.prev)	; Get the previous free block.
+	beq @setheapf		; The previous block is NULL, so set the first block.
+	ldy #fblk.next		; No, so set the offset to the next free block.
+	mov.q (x+y), (b+y)	; Set the previous block's next block, to the next block.
+	bra @chknxtblk		; Check the next block.
 @setheapf:
-	lda.q (sp+9), y	; Get the next block.
-	sta.q heapf	; Set the first heap entry to it.
+	ldy #fblk.next		; Set the offset to the next block.
+	mov.q heapf, (b+y)	; Set the first heap entry to the next block.
 @chknxtblk:
-	lda.q (sp+9), y	; Get the next free block.
-	sta.q sp+1	; Set the third local variable to the next free block.
-	ora.d sp+5	; Is the next block, zero?
-	beq @setheapl	; Yes, so set the least heap entry.
-	ldy #fblk.prev	; No, so get the current previous block.
-	lda.q (sp+9), y	;
-	sta.q (sp+1), y	; Set the next block's previous block to the current previous block.
-	bra @retptr	; Return the pointer.
+	mov.q x, (b+y)		; Get the next free block.
+	beq @setheapl		; The next block is NULL, so set the least heap entry.
+	ldy #fblk.prev		; Get the current previous block.
+	mov.q (x+y), (b+y)	; Set the next block's previous block to the current previous block.
+	bra @retptr		; Return the pointer.
 @setheapl:
-	ldy #fblk.prev	; Get the current previous block.
-	lda.q (sp+9), y	;
-	sta.q heapl	; Set the last heap entry to the current previous block.
-	bra @retptr	; Return the pointer.
+	ldy #fblk.prev		; Get the current previous block.
+	mov.q heapl, (b+y)	; Set the last heap entry to the current previous block.
+	bra @retptr		; Return the pointer.
 @sliceblk:
-	ldy #fblk.size	; Get the size of the current block.
-	lda.q (sp+9), y	;
-	sec		; Prepare for a non borrowing subtract.
-	sbc.q sp+17	; Subtract the current block's size from the passed size.
-	sta.q (sp+9), y	; Set the current block's size to the subtracted size.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+9	; Add the current block's size to the pointer of the current block.
-	sta.q sp+9	; Set the current block to the space above it (return value).
+	ldy #fblk.size		; Get the size of the current block.
+	sub.q (b+y), d		; Subtract the current block's size from the passed size.
+	add.q b, (b+y)		; Add the current block's size to the pointer of the current block.
 @setsize:
-	ldy #ublk.size	; Start setting the used block's size, to the passed size.
-	lda.q sp+17	; Get the passed size.
-	sta.q (sp+9), y	; Set the used block's size to the passed size.
+	mov.q (b+ublk.size), d	; Set the used block's size to the passed size.
 @retptr:
-	ldy #ublk.start	; Start setting the used block's starting address, to the used block.
-	lda.q sp+9	; Get the used block.
-	sta.q (sp+9), y	; Set the used block's starting address, to the used block.
-	clc		; Prepare for a non carrying add.
-	adc #ublk	; Return the pointer to the real memory block.
+	mov.q (b+ublk.start), b	; Set the used block's starting address, to the used block.
+	add b, #ublk		; Get the pointer to the real memory block.
+	tba			; Return the pointer to the real memory block.
 @end:
-	ads #$18	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	rts		; End of malloc.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	rts			; End of malloc.
 
 
 ; free: Free allocated memory.
-; Input: A = Pointer to allocated memory.
+; Input: D = Pointer to allocated memory.
 ; Output: none.
-; Caller preserved registers: none.
-; Callie preserved registers: A, B, Y.
+; Caller preserved registers: D.
+; Callie preserved registers: A, B, X, Y, E.
 
 free:
-	pha.q		; Preserve A.
-	phb.q		; Preserve B.
-	phy.q		; Preserve Y.
-	pha.q		; Push the pointer argument to the stack.
-	and #0		; Reset A.
-	tay		; Reset Y.
-	sbs #$18	; Allocate 3 local variables onto the stack.
-	lda.q sp+25	; Get the passed pointer.
-	ora.d sp+29	; Is the passed pointer NULL?
-	bne @getrealblk	; No, so get the real block.
-	bra @end	; Yes, so we're done.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	phe.q			; Preserve E.
+	and #0			; Reset A.
+	tab			; Reset B.
+	tax			; Reset X.
+	tay			; Reset Y.
+	mov a, d		; Get the passed pointer.
+	bne @getrealblk		; The pointer isn't NULL, so get the real block.
+	bra @end		; The pointer is NULL, so we're done.
 @getrealblk:
-	lda.q sp+25	; Get the passed pointer.
-	sec		; Prepare for a non borrowing subtract.
-	sbc #8		; Move the passed pointer back by one.
-	sta.q sp+25	; Set the first local variable to the start of the used block.
-	lda.q (sp+25)	; Get the real block address.
-	sta.q sp+25	; Set the passed pointer to the start of the real block.
-	ldy #ublk.size	; Get the size of the real block.
-	lda.q (sp+25), y;
-	sta.q sp+17	; Save the size of the real block.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+25	; Add the size of the real block with the start of the real block.
-	cmp.q heapptr	; Is this block on top of the heap?
-	bne @heapadd	; No, so add it to the free block list.
+	sub #8			; Get the start of the used block.
+	mov.q a, (a)		; Get the start of the real block.
+	mov.q b, (a+ublk.size)	; Get the size of the real block.
+	lea e, (a+b)		; Add the size of the real block with the start of the real block.
+	cpe.q heapptr		; Is this block on top of the heap?
+	bne @heapadd		; No, so add it to the free block list.
 @dectop:
-	lda.q sp+25	; Get the block.
-	sta.q heapptr	; Set the top of the heap to it.
+	sta.q heapptr		; Set the top of the heap to the start of the current real block.
 @chklastblk:
-	lda.q heapl	; Get the last free list entry.
-	sta.q sp+17	; Copy it into the second local variable.
-	ora.d sp+21	; Is the free list empty?
-	beq @end	; Yes, so we're done.
-	lda.q sp+17	; No, so Get the last free list entry.
-	ldy #fblk.size	; Get the size of the block.
-	lda.q (sp+17), y;
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the size of the block, with the address of the block entry.
-	cmp.q heapptr	; Is the last block on top of the heap?
-	bne @end	; No, so we're done.
+	ldb.q heapl		; Get the last free list entry.
+	beq @end		; The free list is empty, so we're done.
+	ldy #fblk.size		; Get the size of the block.
+	mov.q a, (b+fblk.size)	; Get the size of the block.
+	lea e, (a+b)		; Add the size of the block, with the address of the block entry.
+	cpe.q heapptr		; Is the last block on top of the heap?
+	bne @end		; No, so we're done.
 @delblk:
-	lda.q sp+17	; Yes, so remove the last block.
-	sta.q heapptr	;
+	stb.q heapptr		; Yes, so remove the last block.
 @correctblk:
-	ldy #fblk.prev	; Get the previous block.
-	lda.q (sp+17), y;
-	sta.q sp+25	; Save the previous block for now.
-	sta.q heapl	; Set the last block to the previous block.
-	ora.d sp+29	; Is the previous block non NULL?
-	bne @delnxtblk	; Yes, so delete the next block.
-	sta.q heapf	; No, so empty the free list.
-	bra @end	; We are done.
+	mov.q a, (b+fblk.prev)	; Get the previous block.
+	sta.q heapl		; Set the last block to the previous block.
+	bne @delnxtblk		; The previous block isn't NULL, so delete the next block.
+	sta.q heapf		; The previous block is NULL, so empty the free list.
+	bra @end		; We are done.
 @delnxtblk:
-	and #0		; Reset A.
-	ldy #fblk.next	; Delete the next block.
-	sta.q (sp+25), y;
+	lea e, (a+fblk.next)	; Delete the next block.
+	stz.q (e)		;
 @end:
-	ads #$20	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	plb.q		; Restore B.
-	pla.q		; Restore A.
-	rts		; End of free.
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
 
 
 @heapadd:
-	lda.q heapf	; Get the first block.
-	sta.q sp+9	; Copy it into the third local variable.
-	ora.d sp+13	; Is the free list empty?
-	bne @srchflst	; No, so start searching the free list.
+	ldy.q heapf		; Get the first block.
+	bne @srchflst		; The Free list isn't empty, so start searching the free list.
 @empty:
-	ldy #fblk.next	; Clear the next block.
-	sta.q (sp+25), y;
-	ldy #fblk.prev	; Clear the previous block.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Reset A.
-	sta.q heapf	; Clear the first block entry.
-	sta.q heapf	; Clear the last block entry.
-	bra @end	; We are done.
+	mov.q (a+fblk.next), y	; Clear the next block.
+	mov.q (a+fblk.prev), y	; Clear the previous block.
+	sta.q heapf		; Set the first block entry to the current block.
+	sta.q heapl		; Set the last block entry to the current block.
+	bra @end		; We are done.
 @srchflst:
-	and #0		; Reset A.
-	sta.q sp+1	; Reset the left pointer.
-	ldy #fblk.next	; Setup for the loop.
 @loop:
-	lda.q sp+9	; Get the right pointer.
-	cmp.q sp+25	; Is the right pointer at, or below the current block?
-	beq @nextright	; Yes, so get the next right pointer.
-	bcs @chkrmerge	; No, so do the right block merge.
+	cmp y, a		; Is the right pointer at, or below the current block?
+	beq @nextright		; Yes, so get the next right pointer.
+	bcs @chkrmerge		; No, so do the right block merge.
 @nextright:
-	sta.q sp+1	; Set the left pointer, to the right pointer.
-	lda.q (sp+9), y	; Get the next right pointer.
-	sta.q sp+9	; Set the current right pointer to the next right pointer.
-	ora.d sp+13	; Is the next right pointer NULL?
-	bne @loop	; No, so keep looping.
+	tyx			; Set the left pointer, to the right pointer.
+	mov.q y, (y+fblk.next)	; Set the current right pointer to the next right pointer.
+	bne @loop		; The next right pointer isn't NULL, so keep looping.
 @st_lmerge2:
-	sta.q (sp+25), y; Clear the next block.
-	lda.q sp+25	; Get the current block.
-	sta.q heapl	; Set the last free block entry to it.
-	bra @chklmerge2	; Do the left block merge.
+	mov.q (a+fblk.next), y	; Clear the next block.
+	sta.q heapl		; Set the last free block entry to it.
+	bra @chklmerge2		; Do the left block merge.
 @chkrmerge:
-	lda.q sp+25	; Get the current block.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the size of the current block, to the current block.
-	cmp.q sp+9	; Is the right pointer NULL?
-	bne @normerge	; No, so don't merge the right block.
+	lea e, (a+b)		; Add the size of the current block, to the current block.
+	cmp e, y		; Is the current block the same as the right block?
+	bne @normerge		; No, so don't merge the right block.
 @rmerge:
-	ldy #fblk.size	; Get the size of the right pointer.
-	lda.q sp+17	; Get the size of the current block.
-	clc		; Prepare for a non carrying add.
-	adc.q (sp+9), y	; Add the size of the current block, with the size of the right pointer.
-	sta.q (sp+25), y; Set the size of the current block, to the new size.
+	mov e, b		; Get the size of the current block.
+	add.q e, (y+fblk.size)	; Add the size of the current block, with the size of the right pointer.
+	mov.q (a+fblk.size), e	; Set the size of the current block, to the new size.
 @rmerge2:
-	ldy #fblk.next	; Get the next right pointer.
-	lda.q (sp+9), y	;
-	sta.q (sp+25), y; Set the next block, to the next right pointer.
-	sta.q sp+17	; Save the next block in the second local variable.
-	ora.d sp+21	; Is the next block NULL?
-	beq @setheapl	; Yes, so set the last block.
+	lea fblk.next		; Get the next right pointer.
+	mov.q (a+e), (y+e)	; Set the next block, to the next right pointer.
+	mov.q b, (y+e)		; Save the next block.
+	beq @setheapl		; The next block is NULL, so set the last block.
 @setprev:
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.prev	; Set the previous block to the current block.
-	sta.q (sp+17), y;
-	bra @chklmerge	; Do the left block merge.
+	mov.q (b+fblk.prev), a	; Set the previous block to the current block.
+	bra @chklmerge		; Do the left block merge.
 @setheapl:
-	lda.q sp+25	; Get the current block.
-	sta.q heapl	; Set the last block to the current block.
-	bra @chklmerge	; Do the left block merge.
+	sta.q heapl		; Set the last block to the current block.
+	bra @chklmerge		; Do the left block merge.
 @normerge:
-	lda.q sp+9	; Get the right pointer.
-	ldy #fblk.next	; Set the next block to the right pointer.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.prev	; Set the previous right pointer to the current block.
-	lda.q (sp+9), y	;
+	mov.q (a+fblk.next), y	; Set the next block to the right pointer.
+	mov.q (y+fblk.prev), a	; Set the previous right pointer to the current block.
 @chklmerge:
-	lda.q sp+1	; Get the left pointer.
-	ora.d sp+5	; Is the left pointer NULL?
-	bne @chklmerge2	; No, so keep checking.
+	and x, x		; Is the left pointer NULL?
+	bne @chklmerge2		; No, so keep checking.
 @newstart:
-	ldy #fblk.prev	; Clear the previous block.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Get the current block.
-	sta.q heapf	; Set the first block, to the current block.
-	bra @end2	; We are done.
+	mov.q (a+fblk.prev), x	;
+	sta.q heapf		; Set the first block, to the current block.
+	bra @end2		; We are done.
 @chklmerge2:
-	ldy #fblk.size	; Get the size of the left block.
-	lda.q (sp+1), y	;
-	clc		; Prepare for a non carrying add.
-	adc.q sp+1	; Add the size of the left block, to the left pointer.
-	cmp.q sp+25	; Is the left block adjacent?
-	bne @nolmerge	; No, so don't merge the left block.
+	mov.q e, (x+fblk.size)	; Get the size of the left block.
+	add e, x		; Add the size of the left block, to the left pointer.
+	cmp e, a		; Is the left block adjacent?
+	bne @nolmerge		; No, so don't merge the left block.
 @lmerge:
-	lda.q (sp+1), y	; Get the size of the left block.
-	clc		; Prepare for a non carrying add.
-	ldb.q (sp+25), y; Get the size of the current block.
-	adc b		; Add the size of the left block, with the size of the current block.
-	sta.q (sp+1), y	; Set the size of the left block to the new size.
+	lea fblk.size		; Set the offset to the block size.
+	add.q (x+e), (a+e)	; Add the size of the left block, with the size of the current block.
 @lmerge2:
-	ldy #fblk.next	; Get the next block.
-	lda.q (sp+25), y;
-	sta.q (sp+1), y	; Set the next left pointer, to the next block.
-	sta.q sp+17	; Set the second local variable to the next block.
-	ora.d sp+21	; Is the next left pointer NULL?
-	beq @newlast	; Yes, so set the last block.
+	lea fblk.next		; Set the offset to the next block.
+	mov.q (x+e), (a+e)	; Set the next left pointer, to the next block.
+	mov.q b, (a+e)		; Get the next block.
+	beq @newlast		; The next block is NULL, so set the last block.
 @lprev:
-	lda.q sp+1	; Get the left pointer.
-	ldy #fblk.prev	; Set the next left pointer's previous pointer to the left pointer.
-	sta.q (sp+17), y;
-	bra @end2	; We are done.
+	mov.q (b+fblk.prev), x	; Set the next left pointer's previous pointer to the left pointer.
+	bra @end2		; We are done.
 @newlast:
-	lda.q sp+1	; Get the left pointer.
-	sta.q heapl	; Set the last block, to the left pointer.
-	bra @end2	; We are done.
+	stx.q heapl		; Set the last block, to the left pointer.
+	bra @end2		; We are done.
 @nolmerge:
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.next	; Set the next left pointer, to the current block.
-	sta.q (sp+1), y	;
+	mov.q (x+fblk.next), a	; Set the next left pointer, to the current block.
 @nolmerge2:
-	lda.q sp+1	; Get the left pointer.
-	ldy #fblk.prev	; Set the previous block, to the left pointer.
-	sta.q (sp+25), y;
+	mov.q (a+fblk.prev), x	; Set the previous block, to the left pointer.
 @end2:
-	ads #$20	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	plb.q		; Restore B.
-	pla.q		; Restore A.
-	rts		; End of free.
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
 
 
 ; memcpy: memory to memory copy.
diff --git a/programs/sub-suite/shift_line.c b/programs/sub-suite/shift_line.c
index 255d21b..365666b 100644
--- a/programs/sub-suite/shift_line.c
+++ b/programs/sub-suite/shift_line.c
@@ -24,6 +24,12 @@ uint8_t bitpos(unsigned int row, uint8_t *mask) {
 
 }
 
+uint8_t getbit(unsigned int row, unsigned int offset) {
+	uint8_t mask;
+	uint8_t byte = bitpos(row+offset, &mask);
+	return (bitabl[byte] & mask);
+}
+
 void setbit(unsigned int row) {
 	uint8_t mask;
 	uint8_t byte = bitpos(row, &mask);
@@ -48,7 +54,7 @@ void shift_line(char *str, int cursor, int left) {
 	if (left) {
 		int i = end-1;
 		int j = end;
-		for (; i > cursor; i--, j--) {
+		for (; i >= cursor; i--, j--) {
 			if (i < 0) {
 				i = 0;
 				str[i] = 0;
@@ -72,7 +78,7 @@ void shift_line(char *str, int cursor, int left) {
 			str[i] = 0;
 		}
 		end = find_end(str, i);
-		if ((end % maxcol) == 0 && (end/maxcol) > scr_row) {
+		if (((end-1) % maxcol) == 0 && ((end-1)/maxcol) > scr_row) {
 			clrbit(end/maxcol);
 		}
 	}
diff --git a/programs/sub-suite/subasm-syntax b/programs/sub-suite/subasm-syntax
new file mode 100644
index 0000000..1337914
--- /dev/null
+++ b/programs/sub-suite/subasm-syntax
@@ -0,0 +1,56 @@
+/* Assembly language syntax for SuBAsm. */
+
+/* Comments begin with "/*", and end with "*/".
+ * Directives begin with a `\`.
+ */
+
+/* mnemonic is the instruction name/mnemonic.
+ * expr is an expression.
+ * Indirect Indexed means applying the index after the indirection.
+ * Indexed Indirect means applying the index before the indirection.
+ */
+
+Expression syntax:
+	/* TODO */
+Instruction syntax:
+	Base ISA, and Base Extension:
+		Implied:
+			<mnemonic>
+		B register:
+			<mnemonic> b
+		Absolute/Zero Matrix:
+			/* [, <x|y>] means Indexed with x, or y. */
+			<mnemonic> <expr>[, <x|y>]
+		Immediate Data:
+			<mnemonic> #<expr>
+		Absolute/Zero Matrix Indirect:
+			/* Indexing with x means Indexed Indirect.
+			 * Indexing with y means Indirect Indexed.
+			 */
+			<mnemonic> (<expr>[, x])[, y]
+		E Indirect:
+			<mnemonic> (e)
+	Orthogonal Extension:
+		<mnemonic> <operand>[, operand]
+		Operand syntax:
+			<\(
+				/* The operand starts with a register.
+				 * If the statment is inside brackets, then
+				 * it's a register indirect mode.
+				 */
+				[(]reg[+<reg>][\(+|-\)<expr>][)]
+				/* The operand starts with an expression.
+				 * If the statment is inside brackets, then
+				 * it's an indirect mode.
+				 */
+				|[(]expr
+				/* Is the operand using Indirect, or Indirect Indexed? */
+				\if (ind || ind_indexed) {
+					[)]
+				\}
+				[\(+|-\)<reg[+<reg>]>]
+				/* Is the operand using Indexed Indirect? */
+				\if (indexed_ind) {
+					[)]
+				\}
+			\)>
diff --git a/programs/sub-suite/subasm.s b/programs/sub-suite/subasm.s
index 80aaa47..f22ee60 100644
--- a/programs/sub-suite/subasm.s
+++ b/programs/sub-suite/subasm.s
@@ -3,153 +3,260 @@
 ;
 ; by mr b0nk 500 <b0nk@b0nk.xyz>
 
+;subasm:
+;	ldb #0		; Set the first pointer
+;	lda.q cmd_buf	; to the command buffer.
+;	jsr set_ptr	;
+;	tba		; Reset A.
+;	tax		; Reset X.
+;	jsr chk_shcmd	; Did we get a shortend command?
+;	bne @cmd	; Yes, so skip everything else.
+;	jsr chk_cmd	; No, but did we get a full command?
+;	bne @cmd	; Yes, so skip everything else.
+;	jsr lex		; No, so start lexing this line.
+;	bra @end	; We are done.
+;@cmd:
+;	lda regf	; Get the command ID.
+;	cmp #8		; Is the command ID greater than the command count?
+;	bcs @end	; Yes, so we're done.
+;	lsl #1		; No, so multiply the command ID by two.
+;	phx.q		; Preserve X.
+;	tax             ; Set the index to the offset that we just calculated.
+;	lea.w (cmd_srt, x); Get the pointer, from the command subroutine table.
+;	plx.q		; Restore X.
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;	jsr (e)		; Run the command's subroutine.
+;@end:
+;	and #0		; Reset A.
+;	jsr update_ptr	; Get the screen buffer index.
+;	tay		; Save it in Y.
+;	and #0		; Reset A.
+;	rts		; End of subasm.
+;
+;chk_shcmd:
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;;	inb		; Set the second pointer
+;;	lda.w #sh_cmds	; to the shortend command table.
+;;	jsr set_ptr	;
+;;	deb		; Reset B.
+;;	tba		; Reset A.
+;	lea sh_cmds	; Get the address of the short command table.
+;	phy.w		; Preserve the screen buffer position.
+;	txy		; Set our index to zero.
+;	lda (ptr), y	; Is there nothing in the command buffer?
+;	beq @false	; Yes, so return that we failed.
+;	cmp #' '	; No, but is this character, a space?
+;	beq @false	; Yes, so return that we failed.
+;	jsr tolower	; No, so convert it to lowercase.
+;@loop:
+;;	ldb (ptr2), y	; Are we at the end of the table?
+;	ldb (e)		; Are we at the end of the table?
+;	beq @false	; Yes, so return that we failed.
+;	cmp b		; No, so did the character match?
+;	beq @found	; Yes, so check if there are any arguments.
+;	ine		; No, so check the next command.
+;	iny		;
+;	bra @loop	; Keep looping.
+;@found:
+;	sty regf	; Save the command ID.
+;	lea (ptr)	; Get the address of the next character.
+;	ine		;
+;;	ldy #1		; Check the next character in the command buffer.
+;;	lda (ptr), y	; Is this the end of the buffer?
+;	lda (e)		; Is this the end of the buffer?
+;	beq @true	; Yes, so return true.
+;	cmp #' '	; No, but is this a space?
+;	beq @true	; Yes, so return true.
+;@false:
+;	ldb #0		; Reset B.
+;	tba		; Return false.
+;	tax		; Reset X.
+;	bra @end	; We are done.
+;@true:
+;	lda #1		; Return true.
+;@end:
+;	ply.w		; Get back the screen buffer position.
+;	rts		; End of chk_shcmd.
+;
+;
+;chk_cmd:
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;	tax		; Reset X.
+;	sta.q idx0	; Reset the first index.
+;	sta.q idx1	; Reset the second index.
+;	mov.q ptr, d	; Set the first pointer to the command buffer.
+;@loop:
+;	lda.w #cmds	; Get pointer to the start of the command table.
+;	add.w idx0	; Offset the pointer, by the length of the previous string.
+;	pha.q		; Preserve the command string pointer.
+;	jsr strcaseg	; Is the command buffer, the same as the command string?
+;	pla.q		; Get the command string pointer back.
+;	beq @true	; Yes, so return true.
+;	ldb idx1	; No, so Get the command ID.
+;	cpb #7		; Have we reached the end of the command table?
+;	beq @false	; Yes, so return false.
+;	inc idx1	; No, so increment the command ID.
+;@getlen:
+;	mov d, a	; Get the string.
+;	jsr strlen	; Get the string's length.
+;	inc		; Add one to the length.
+;	add.w idx0, a	; Add the string offset to the current length
+;	bra @loop	; Keep looping.
+;@true:
+;	ldb idx1	; Get the command ID.
+;	stb regf	; Return the command ID.
+;	ldb #1		; Return true.
+;	bra @end	; We are done.
+;@false:
+;	ldb #0		; Return false.
+;@end:
+;	rts		; End of chk_cmd.
+
+
 subasm:
-	ldb #0		; Set the first pointer
-	lda.q cmd_buf	; to the command buffer.
-	jsr set_ptr	;
-	tba		; Reset A.
-	tax		; Reset X.
-	jsr chk_shcmd	; Did we get a shortend command?
-	bne @cmd	; Yes, so skip everything else.
-	jsr chk_cmd	; No, but did we get a full command?
-	bne @cmd	; Yes, so skip everything else.
-	jsr lex		; No, so start lexing this line.
-	bra @end	; We are done.
+	pha.q			; Preserve A.
+	phe.q			; Preserve E.
+	des			; Make room for the command id.
+	and #0			; Reset A.
+	lea d, (cmd_buf)	; Get the command buffer.
+	lea s, (sp+1)		; Get the pointer to the command id.
+	jsr chk_shcmd		; Did we get a shortend command?
+	bne @cmd		; Yes, so skip everything else.
+	jsr chk_cmd		; No, but did we get a full command?
+	bne @cmd		; Yes, so skip everything else.
+	mov.q ptr, d		;
+	jsr lex			; No, so start lexing this line.
+	bra @end		; We are done.
 @cmd:
-	lda regf	; Get the command ID.
-	cmp #8		; Is the command ID greater than the command count?
-	bcs @end	; Yes, so we're done.
-	lsl #1		; No, so multiply the command ID by two.
-	phx.q		; Preserve X.
-	tax             ; Set the index to the offset that we just calculated.
-	lea.w (cmd_srt, x); Get the pointer, from the command subroutine table.
-	plx.q		; Restore X.
-	and #0		; Reset A.
-	tab		; Reset B.
-	jsr (e)		; Run the command's subroutine.
+	mov s, (s)		; Get the command ID.
+	cmp s, #7		; Is the command ID greater than the command count?
+	bcs @end		; Yes, so we're done.
+	lsl s, #1		; No, so multiply the command ID by two.
+	lea.w e, (cmd_srt+s)	; Get the pointer, from the command subroutine table.
+	and #0			; Reset A.
+	tab			; Reset B.
+	jsr (e)			; Run the command's subroutine.
 @end:
-	and #0		; Reset A.
-	jsr update_ptr	; Get the screen buffer index.
-	tay		; Save it in Y.
-	and #0		; Reset A.
-	rts		; End of subasm.
+	and #0			; Reset A.
+	jsr update_ptr		; Get the screen buffer index.
+	tay			; Save it in Y.
+	ins			; Cleanup the stack frame.
+	ple.q			; Restore E.
+	pla.q			; Restore A.
+	rts			; End of subasm.
+
 
 chk_shcmd:
-	and #0		; Reset A.
-	tab		; Reset B.
-;	inb		; Set the second pointer
-;	lda.w #sh_cmds	; to the shortend command table.
-;	jsr set_ptr	;
-;	deb		; Reset B.
-;	tba		; Reset A.
-	lea sh_cmds	; Get the address of the short command table.
-	phy.w		; Preserve the screen buffer position.
-	txy		; Set our index to zero.
-	lda (ptr), y	; Is there nothing in the command buffer?
-	beq @false	; Yes, so return that we failed.
-	cmp #' '	; No, but is this character, a space?
-	beq @false	; Yes, so return that we failed.
-	jsr tolower	; No, so convert it to lowercase.
+	phb.q			; Preserve B.
+	lea b, sh_cmds		; Get the address of the short command table.
+	mov a, (d)		; Is the string empty?
+	beq @false		; Yes, so return that we failed.
+	cmp #' '		; No, but is this character, a space?
+	beq @false		; Yes, so return that we failed.
+	jsr tolower		; No, so convert it to lowercase.
 @loop:
-;	ldb (ptr2), y	; Are we at the end of the table?
-	ldb (e)		; Are we at the end of the table?
-	beq @false	; Yes, so return that we failed.
-	cmp b		; No, so did the character match?
-	beq @found	; Yes, so check if there are any arguments.
-	ine		; No, so check the next command.
-	iny		;
-	bra @loop	; Keep looping.
+	cmp (b), #0		; Are we at the end of the table?
+	beq @false		; Yes, so return that we failed.
+	cmp a, (b)		; No, so did the character match?
+	beq @found		; Yes, so check if there are any arguments.
+	inb			; No, so check the next command.
+	bra @loop		; Keep looping.
 @found:
-	sty regf	; Save the command ID.
-	lea (ptr)	; Get the address of the next character.
-	ine		;
-;	ldy #1		; Check the next character in the command buffer.
-;	lda (ptr), y	; Is this the end of the buffer?
-	lda (e)		; Is this the end of the buffer?
-	beq @true	; Yes, so return true.
-	cmp #' '	; No, but is this a space?
-	beq @true	; Yes, so return true.
+	sub.w b, #sh_cmds	; Get the command ID.
+	mov (s), b		; Save the command ID.
+	mov a, (d+1)		; Is this the end of the string?
+	beq @true		; Yes, so return true.
+	cmp #' '		; No, but is this a space?
+	beq @true		; Yes, so return true.
 @false:
-	ldb #0		; Reset B.
-	tba		; Return false.
-	tax		; Reset X.
-	bra @end	; We are done.
+	and #0			; Return false.
+	bra @end		; We are done.
 @true:
-	lda #1		; Return true.
+	lda #1			; Return true.
 @end:
-	ply.w		; Get back the screen buffer position.
-	rts		; End of chk_shcmd.
+	plb.q			; Restore B.
+	rts			; End of chk_shcmd.
 
 
 chk_cmd:
-	tba		; Reset A.
-	tax		; Reset X.
-	sta.q idx0	; Reset the first index.
-	sta.q idx1	; Reset the second index.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	and #0			; Reset A.
+	tab			; Reset B.
+	mov x, s		; Preserve the command ID pointer.
+	mov y, d		; Preserve the string pointer.
+	lea s, cmds		; Get pointer to the start of the command table.
 @loop:
-	lda.w #cmds	; Get pointer to the start of the command table.
-	clc		; Prepare for a non carrying add.
-	adc.w idx0	; Offset the pointer, by the length of the previous string.
-	pha.q		; Preserve the command string pointer.
-	jsr strcaseg	; Is the command buffer, the same as the command string?
-	pla.q		; Get the command string pointer back.
-	beq @true	; Yes, so return true.
-	ldb idx1	; No, so Get the command ID.
-	cpb #7		; Have we reached the end of the command table?
-	beq @false	; Yes, so return false.
-	inc idx1	; No, so increment the command ID.
+	jsr strcasecmp		; Is the command buffer, the same as the command string?
+	beq @true		; Yes, so return true.
+	inb			; No, so increment the command ID.
+	cpb #7			; Have we reached the end of the command table?
+	bcs @false		; Yes, so return false.
 @getlen:
-	jsr strlen	; Get the string's length.
-	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx0	; Add the string offset to the current length
-	sta.w idx0	; Save the offset in the first index.
-	bra @loop	; Keep looping.
+	mov d, s		; Get the command table string.
+	jsr strlen		; Get the string's length.
+	mov d, y		; Restore the string pointer.
+	inc			; Add one to the length.
+	add s, a		; Add the string offset to the current length
+	bra @loop		; Keep looping.
 @true:
-	ldb idx1	; Get the command ID.
-	stb regf	; Return the command ID.
-	ldb #1		; Return true.
-	bra @end	; We are done.
+	lda #1			; Return true.
+	bra @end		; We are done.
 @false:
-	ldb #0		; Return false.
+	lda #0			; Return false.
 @end:
-	rts		; End of chk_cmd.
+	mov s, x		; Restore the command ID pointer.
+	mov (s), b		; Save the command ID.
+	and a, a		; Set the flags accordingly.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	rts			; End of chk_cmd.
+
 
 viewmem:
-	lda.q prg_cnt	; Get the program counter.
-	sta.q idx0	; Save the address in the first index.
-	and #$F0	; Clear the first four bits of the address.
-	sta idx0	; Overwrite the first byte, with the masked byte.
-	lda #19		; Move the cursor to the right, by 19 columns.
-	sta scr_col	;
-	jsr update_pos	;
-	jsr print_lo	; Print the low nibble offsets.
-	ldx #0		; Reset X.
-	ldb #0		; Reset B.
-	stb idx1	; Reset the byte count.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	sbs #$50		; Make room for the string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	ldx.q prg_cnt		; Get the program counter.
+	lda #19			; Move the cursor to the right, by 19 columns.
+	sta scr_col		;
+	jsr update_pos		;
+	jsr print_lo		; Print the low nibble offsets.
 @loop:
-	lda #'\n'	; Print a newline.
-	jsr print_char	;
-	jsr print_hi	; Place the address in the string buffer.
-	jsr print_chunk	; Place the next 16 bytes in the string buffer.
-	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-	jsr print_sfast	;
-	inc idx1	; Increment the chunk count.
-	ldb idx1	; Get the chunk count.
-	cpb #$10	; Did we print 16 chunks?
-	beq @end	; Yes, so we're done.
-	lda.q idx0	; No, so get the address index.
-	clc		; Prepare for a non carrying add.
-	adc #$10	; Add 16 to the address.
-	sta.q idx0	; Put it back into the address.
-	and #0		; Reset A.
-	bra @loop	; Keep looping.
+	lda #'\n'		; Print a newline.
+	jsr print_char		;
+	lea d, (sp+1)		; Get the address of the string buffer.
+	mov s, x		; Get the program counter.
+	jsr print_hi		; Print the address to the string buffer.
+	mov d, a		; Get the string buffer pointer after the printed address.
+	mov s, x		; Get the program counter.
+	jsr print_chunk		; Print the next 16 bytes to the string buffer.
+	lea d, (sp+1)		; Get the address of the string buffer.
+	lea s, (buffer)+y	; Get the address of the screen buffer, at the current cursor position.
+;	jsr print_str		; Print the string buffer.
+	jsr print_sfast		;
+	inb			; Increment the chunk count.
+	cpb #$10		; Did we print 16 chunks?
+	beq @end		; Yes, so we're done.
+	add x, #$10		; No, so add 16 to the address.
+	and #0			; Reset A.
+	bra @loop		; Keep looping.
 @end:
-	lda #'\n'	; Print a newline.
-	jsr print_char	;
-	and #0		; Reset A.
-	rts		; End of viewmem.
+	lda #'\n'		; Print a newline.
+	jsr print_char		;
+	ads #$50		; Cleanup the stack frame.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of viewmem.
 
 
 list:
@@ -164,10 +271,10 @@ help:
 	nop		;
 @end:
 	rts		; End of help.
-inst:
+instruction:
 	nop		;
 @end:
-	rts		; End of inst.
+	rts		; End of instruction.
 run:
 	nop		;
 @end:
diff --git a/programs/sub-suite/subeditor.s b/programs/sub-suite/subeditor.s
index 387b5db..f6b647f 100644
--- a/programs/sub-suite/subeditor.s
+++ b/programs/sub-suite/subeditor.s
@@ -11,8 +11,8 @@ reset:
 	ldy #0		; Reset Y.
 	tyx		; Reset X.
 	jsr init_heap	; Initialize the heap.
-	tax		; Set the stack pointer to the end of RAM.
-	txs		;
+	mov sp, a	; Set the stack pointer to the end of RAM.
+;	txs		;
 	sub.d #STKSIZE	; Subtract the stack size, from the end of RAM.
 	sta.q heapend	; Save the end of the heap.
 	and #0		; Reset A.
@@ -28,45 +28,39 @@ reset:
 init_heap:
 	lea HEAPORG	; Get the heap's starting point.
 	ste.q heapptr	;
+	mov d, e	;
 	jsr findramend	; Find the end of the heap.
 	rts		; End of init_heap.
 
 
 init_tables:
-	and #0		; Reset A.
-	lda.w #SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
+	lea d, SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
 	jsr malloc	;
 	sta.q buffer	;
-	and #0		; Reset A.
-	lda.w #CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
+	lea d, CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
 	jsr malloc	;
 	sta.q cmd_buf	;
-	and #0		; Reset A.
-	lda.w #LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
+	lea d, LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
 	jsr malloc	;
 	sta.q bitabl	;
-	and #0		; Reset A.
 	rts		; End of init_tables.
 
 
 ;test_free:
 ;	inc step	;
-;	lda.q bitabl	;
+;	mov.q d, bitabl	;
 ;	jsr free	;
-;	lda.q buffer	;
+;	mov.q d, buffer	;
 ;	jsr free	;
-;	and #0		; Reset A.
-;	lda.w #LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
+;	lea d, LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
 ;	jsr malloc	;
 ;	sta.q bitabl	;
-;	lda.q cmd_buf	;
+;	mov.q d, cmd_buf;
 ;	jsr free	;
-;	and #0		; Reset A.
-;	lda.w #SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
+;	lea d, SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
 ;	jsr malloc	;
 ;	sta.q buffer	;
-;	and #0		; Reset A.
-;	lda.w #CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
+;	lea d, CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
 ;	jsr malloc	;
 ;	sta.q cmd_buf	;
 ;	and #0		; Reset A.
@@ -74,33 +68,38 @@ init_tables:
 
 
 clr_arr:
-	stz.q (e)	; Clear eight bytes.
-	ade #8		; Increment the pointer by 8.
-	stz.q (e)	; Clear eight bytes.
-	ade #8		; Increment the pointer by 8.
-	sub #$10	; Subtract 16 from the size.
+	pha.q		; Preserve A.
+	and #0		; Reset A.
+@loop:
+	mov.q (d), a	; Clear 16 bytes.
+	mov.q (d+8), a	;
+	add d, #$10	; Increment the pointer by 16.
+	sub s, #$10	; Subtract 16 from the size.
 	bcc @end	; We've reached the end of the array, so we're done.
 	beq @end	;
-	bra clr_arr	; Keep looping.
+	bra @loop	; Keep looping.
 @end:
+	pla.q		; Restore A.
 	rts		; End of clr_arr.
 
 
 pnt_strt:
-	lea ed_name	; Print the name of the editor.
+	lea d, ed_name	; Print the name of the editor.
 	jsr print_str	;
-	lea ver_str	; Print the version text.
+	lea d, ver_str	; Print the version text.
 	jsr print_str	;
-	lea ed_ver	; Print the version number.
+	lea d, ed_ver	; Print the version number.
 	jsr print_str	;
-	lea ed_sver	; Print the sub version number.
+	lea d, ed_sver	; Print the sub version number.
 	jsr print_str	;
+	lea d, '\n'	; Print a newline.
 	lda #'\n'	; Print a newline.
 	jsr print_char	;
-	lea made	; Print the "Created by" text.
+	lea d, made	; Print the "Created by" text.
 	jsr print_str	;
-	lea author	; Print the name of the author.
+	lea d, author	; Print the name of the author.
 	jsr print_str	;
+	lea d, '\n'	; Print a newline.
 	lda #'\n'	; Print a newline.
 	jsr print_char	;
 	rts		; End of pnt_strt.
@@ -109,8 +108,8 @@ pnt_strt:
 clr_cmd:
 	and #0		; Reset A.
 	tay		; Reset Y.
-	lda.w #CMDSIZE	; Set the clear count to CMDSIZE.
-	lea (cmd_buf)	; Set the array to be cleared to the command buffer.
+	lea s, CMDSIZE	; Set the clear count to CMDSIZE.
+	lea d, (cmd_buf); Set the array to be cleared to the command buffer.
 	jsr clr_arr	; Clear the command buffer.
 	rts		; End of clr_cmd.
 
@@ -149,140 +148,68 @@ getchar:
 
 
 print_str:
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
 	and #0		; Reset A.
 	tba		; Reset B.
 @loop:
-	ldb #1		; Enable replace mode.
-	stb regb	;
-	and #0		; No, reset the accumulator.
-	ldb (e)		; Are we at the end of the string?
+	mov regb, #1	; Enable replace mode.
+	and #0		; Reset A.
+	mov b, (d)	; Are we at the end of the string?
 	beq @end	; Yes, so we're done.
 	jsr update_ptr	; No, so get the screen buffer index.
 	tay		; Save it in Y.
 	tba		; Get the character back.
-	ine             ; Increment the string pointer.
+	inc d		; Increment the string pointer.
 	jsr print_char	; Print the character.
 	bra @loop	; Keep looping.
 @end:
 	stz regb	; Enable insert mode.
 	and #0		; Reset A.
 	tab		; Reset B.
+	pla.q		; Restore A.
+	plb.q		; Restore B.
 	rts		; End of print_str.
 
 
-;print_str:
-;	ldx #0		; Reset X.
-;	sta.q end	; Save the parameter.
-;@reset:
-;	lda.q end	; Get the parameter.
-;	ldb #0		; Clear the B register.
-;	jsr set_ptr	; Set the first pointer to the parameter.
-;	tba		; Clear the Accumulator.
-;@loop:
-;	ldb #1		; Enable replace mode.
-;	stb regb	;
-;	lda.q ptr	; Get the first pointer.
-;	cmp.q end	; Did the pointer change?
-;	bne @reset	; Yes, so set it back.
-;	and #0		; No, reset the accumulator.
-;	txy		; Copy the string index into Y.
-;	ldb (ptr), y    ; Are we at the end of the string?
-;	beq @end	; Yes, so we're done.
-;	jsr update_ptr	; No, so get the screen buffer index.
-;	tay		; Save it in Y.
-;	tba		; Get the character back.
-;	inx             ; Increment the string index.
-;	phx		; Preserve the string index.
-;	jsr print_char	; Print the character.
-;	plx		; Get the string index back.
-;	bra @loop	; Keep looping.
-;@end:
-;	stz regb	; Enable insert mode.
-;	and #0		; Reset A.
-;	tab		; Reset B.
-;	rts		; End of print_str.
-
 getbit:
-	clc		; Clear the carry flag.
-	lda scr_str	; Has the screen been scrolled?
-	bne getbt0	; Yes, so add the screen offset to the current line number.
-	ldx scr_row	; No, so just use the current line number.
-	bra getbt1	; Start getting the bit.
-getbt0:
-	lda scr_row	; Get the current line number.
-	adc scr_str	; Add the screen offset to it.
-	tax		; Use it as the wrap index.
-getbt1:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	lsr #$10	; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	ply.w		; Get the screen index back.
-	and b		; Mask out the bit of the current line number.
-	cmp #1		; Set the carry flag, if true.
-	bra bitout	; We are done.
+	des			; Create the stack frame.
+	add d, s		; Add the row position with the row offset position.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	mov a, (bitabl)+a	; Get the bit of the row position.
+	and a, (s)		; Return the masked bit.
+	rts			; End of getbit.
+
 
 clrbit:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	xor #$FF	; Invert the bitmask.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	and b		; Clear the bit of the current line number.
-bitsav:
-	sta (ptr2), y	; Update the wrap table.
-	ply.w		; Get the screen index back.
-bitout:
-	ldx bitmask	; Return the bitmask.
-	rts		; We are done.
+	pha.q			; Preserve A.
+	des			; Create the stack frame.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	not (s)			; Invert the bitmask.
+	and (bitabl)+a, (s)	; Set the bit of the current row number to zero.
+	pla.q			; Restore A.
+	rts			; End of clrbit.
 
 setbit:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	ora b		; Set the bit of the current line number.
-	bra bitsav	; Save the bit.
+	pha.q			; Preserve A.
+	des			; Create the stack frame.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	or  (bitabl)+a, (s)	; Set the bit of the current row number to one.
+	pla.q			; Restore A.
+	rts			; End of setbit.
 
 bitpos:
-	pha 		; Save the parameter.
-	ldb #0		; Make sure that set_ptr sets the first pointer.
-	lda.w #bits	; Set the first pointer to the bitmask table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the parameter back.
-	stx bitmask	; Make the line number the bitmask.
-	txa		; Copy it to the Accumulator.
-	and #7		; Get the bit position.
-	phy.w		; Save the cursor index.
-	tay		; Use the bit position as the index.
-	tax		; Copy it into X.
-	lda (ptr), y	; Get the bitmask.
-	ply.w		; Get back the cursor index.
-	pha 		; Save the bitmask.
-	lda bitmask	; Get the line number.
-	lsr #3		; Get the byte position.
-	tax		; Copy it into X.
-	pla 		; Get back the bitmask.
-	rts		; End of bitpos.
+	mov a, d		; Preserve the row number.
+	and d, #7		; Get the bit position.
+	lsr #3			; Return the byte position.
+	mov (s), (d+bits)	; Place the bitmask into the mask argument.
+	rts			; End of bitpos.
 
 
 handle_char:
@@ -328,7 +255,10 @@ handle_char:
 cmd_cpy:
 	lda scr_row	; Get the row position.
 	sta scr_trow	; Save it for later.
-	jsr findend	; Find the end of the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr find_end	; Find the end of the line.
+	div #maxcol+1	; Get the ending line.
 	ldb scr_str	; Has the screen been scrolled?
 	beq @start	; No, so don't subtract the screen's starting point from the line number.
 @offset:
@@ -388,48 +318,45 @@ cmd_cpy:
 
 
 findst:
-	lda #0		; Reset A.
+;	lda #0		; Reset A.
+;	xor d, d	; Reset D.
+;	xor s, s	; Reset S.
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 @loop:
-	pha 		; Save the current line number.
+;	pha 		; Save the current line number.
 	jsr getbit	; Is this the start of the line?
-	pla 		; Get the current line number back.
-	bcc @end	; Yes, so we're done.
-	inc		; No, so check the next physical line.
+;	pla 		; Get the current line number back.
+	beq @end	; Yes, so we're done.
+	inc d		; No, so check the next physical line.
 	dec scr_row	; Are we at the top of the screen?
 	bpo @loop	; No, so keep looping.
-	dec		; Yes, so move back one line.
+	dec d		; Yes, so move back one line.
 	inc scr_row	; Put the row postiion back to zero.
 @end:
-	cmp #0		; Update all the flags.
+	cmp d, #0	; Update all the flags.
 	rts		; End of findst.
 
 
-fndend:
-	phb 		; Save the contents of the B register.
-	ldb #0		; Make sure that set_ptr sets the first pointer.
-	lda.q buffer	; Set the first pointer to the start of the screen buffer.
-	jsr set_ptr	;
-	tba		; Set the Accumulator to zero.
-	plb 		; Restore the contents of the B register.
-	phy.w		;
+find_end:
+	mov a, s	; Set the loop counter.
 @loop:
-	lda (ptr), y	; Are we at the end of the string?
-	beq @end	; Yes, so we're done.
-	iny		; No, so increment the cursor index.
-	bra @loop	; Keep looping.
+	inc		; Increment the loop counter.
+	cmp (d+a-1), #0	; Did we hit the null terminator?
+	bne @loop	; No, so keep looping.
 @end:
-	sty.w scr_ptr3	;
-	ply.w		;
-	rts		; End of fndend.
-
-findend:
-	jsr fndend	;
-	lda.w scr_ptr3	;
-	div #maxcol+1	;
-	rts		;
+	rts		; End of find_end.
+
+
+get_endrow:
+	jsr find_end	; Find the end of the line.
+	div #maxcol+1	; Get the ending row.
+	rts		; End of get_endrow
 
 
 print_char:
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phe.q		; Preserve E.
 	sta rega	; Preserve the character.
 	ldb #2		; Make sure that set_ptr sets the third pointer.
@@ -441,15 +368,13 @@ print_char:
 	lda rega	; Get the character back.
 	jsr get_ctrlidx	; Get the control code jump table index.
 	lsl #1		; Multiply the return value by two, to get the index.
-	tax		;
-	lea.w (ct_jtb, x); Get the address of the control code handler.
-;	pha.q		;
-;	ple.q		;
-;	jsr set_ptr	; Set the second pointer to the control code handler.
+	lea.w e, (ct_jtb+a); Get the address of the control code handler.
 	deb		; Reset B.
 	tba		; Reset A.
 	jsr (e)		; Jump to the handler for that control code.
 	ple.q		; Restore E.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts
 printc:
 	lda #0		; start trying to print a character.
@@ -458,18 +383,20 @@ printc:
 	beq @save	; Yes, so just print the character.
 	lda regb	; No, but was the flag set?
 	bne @save	; Yes, so don't shift the line.
-	sty.w scr_ptr	; No, so save the cursor index for later.
-	jsr fndend	; Find the end of the line.
+;	sty.w scr_ptr	; No, so save the cursor index for later.
+;	jsr fndend	; Find the end of the line.
 	bra @shift	; Start shifting the line right.
 @update:
 	lda scr_col	; Save the current column position for later.
 	sta scr_tcol	;
 @update1:
-	jsr findend	; Find the end of the line.
-	sta rege	; Use it for redrawing the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Get the ending line.
+	mov d, a	;
+	mov s, scr_trow	; Get the current row position.
 	lda scr_trow	; Get the current row position.
 @update2:
-	sta regf	; Set the starting line, to the current row position.
 	jsr rdrw_ln	; Redraw the line.
 	lda scr_trow	; Get the real row position back.
 	sta scr_row	;
@@ -479,12 +406,15 @@ printc:
 	dec regd	;
 	bra @save1	;
 @shift:
-	ldy.w scr_ptr3	;
-	inc scr_ptr3	;
-	tyx		;
-	dey		;
-	ldb #1		;
-	stb regd	;
+;	ldy.w scr_ptr3	;
+;	inc scr_ptr3	;
+;	tyx		;
+;	dey		;
+;	ldb #1		;
+;	stb regd	;
+	lea d, (buffer)	; Get the screen buffer.
+	mov.w s, scr_ptr; Get the cursor index.
+	mov f, #1	; Set the left flag to true.
 	jsr shftln	;
 	ldb #1		;
 	stb regd	;
@@ -501,6 +431,7 @@ printc:
 	sta (ptr3), y	; store typed character into the input buffer.
 @incr:
 	inc scr_col	; Increment the cursor's x coordinate.
+	inc.w scr_ptr	; Increment the screen index.
 	iny		;
 @wrapped:
 	ldb #1		;
@@ -536,13 +467,15 @@ printc:
 @wrap1:
 	inc scr_row	;
 @wrap2:
-	phx.w		;
-	clc		;
-	lda scr_row	;
-	adc scr_str	;
-	tax		;
-	jsr setbit	;
-	plx.w		;
+;	phx.w		;
+;	clc		;
+;	lda scr_row	;
+;	adc scr_str	;
+;	tax		;
+	mov d, scr_row	; Get the row position.
+	add d, scr_str	; Add the row offset to the row position.
+	jsr setbit	; Set the bit of that row.
+;	plx.w		;
 	jsr update_pos	;
 printc_end:
 	rts		;
@@ -573,11 +506,11 @@ clr_scr:
 	sta scr_end	;
 	stz scr_str	;
 	tay		;
-	lda.w #LWSIZE	; Set the clear count to LWSIZE.
-	lea (bitabl)	; Set the array to be cleared to the linewrap table.
+	lea s, LWSIZE	; Set the clear count to LWSIZE.
+	lea d, (bitabl)	; Set the array to be cleared to the linewrap table.
 	jsr clr_arr	; Clear the linewrap table.
-	lda.w #SCRSIZE	; Set the clear count to SCRSIZE.
-	lea (buffer)	; Set the array to be cleared to the screen buffer.
+	lea s, SCRSIZE	; Set the clear count to SCRSIZE.
+	lea d, (buffer)	; Set the array to be cleared to the screen buffer.
 	jsr clr_arr	; Clear the screen buffer.
 ;	lda.w #CMDSIZE	; Set the clear count to CMDSIZE.
 ;	lea (cmd_buf)	; Set the array to be cleared to the command buffer.
@@ -613,8 +546,10 @@ bs:
 	beq @wrap	; Yes, so check for a wrapped line.
 	bra back	; No, so add the backspace to the buffer.
 @wrap:
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is this line, a wrapped line?
-	bcs @wrap1	; Yes, so check if the cursor is at the top.
+	bne @wrap1	; Yes, so check if the cursor is at the top.
 	rts		; No, so we're done.
 @wrap1:
 	lda scr_row	; Are we at the top of the screen?
@@ -644,7 +579,9 @@ back:
 	stb regf	;
 	lda scr_row	; Save the current row position for later.
 	sta scr_trow	;
-	jsr findend	; Find the end of the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Get the ending line.
 	sta scr_row	; Set our row position to the end of the line.
 @find_st:
 	jsr findst	; Does this line take up more than one real line?
@@ -660,14 +597,20 @@ back:
 	iny		; Increment cursor index.
 	ldb #0		; Set shifting direction to left.
 	stb regd	;
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	mov f, #0	; Set the left flag to false.
 	jsr shftln	; Shift line back by one character.
 	lda #$7F	; Print a backspace to the screen.
 	sta scr		;
 	lda rege	; Are we updating more than one line?
 	beq @load	; No, so skip to the next step.
 @find_end:
-	jsr findend	; Yes, so find the end of the line.
-	sta rege	; Set the end parameter to it.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Yes, so Get the ending line.
+	mov d, a	;
+	mov s, scr_trow	; Get the current row position.
 	lda scr_col	; Save the current column position for now.
 	sta scr_tcol	;
 	jsr rdrw_ln	; Start redrawing the line.
@@ -683,88 +626,73 @@ back:
 	lda (ptr3), y	; Are we at the end of the line?
 	beq @shift	; Yes, so skip redrawing.
 	lda scr_trow	; No, so set the line to start redrawing, to the line that the cursor is on.
-	sta regf	;
 	inc rege	; Set the redraw flag to true.
 	bra @shift	; Start shifting the line back.
 
 
 shftln:
-	ldb regd	; Is the flag not set?
-	beq @dec_loop	; Yes, so shift, and decrement.
-	ldb #0		; Clear the B register.
-	bra @inc_loop	; No, so shift, and increment.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	and f, f		; Is the left flag not set?
+	beq @right		; Yes, so shift the line to the right.
+;	txa			; Get the end of the line.
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the source position.
+	bra @left		; No, so shift the line to the left.
 @minus:
-	ldy.w zero	; Set the source poition to 0.
-	stb (ptr3), y	; Clear the character that is in the source.
-	bra @end	; We are done.
-@inc_loop:
-	sty.w scr_ptr2	; Save the source position for later.
-	ldy.w scr_ptr	; Get the previous cursor index.
-	cpy.w scr_ptr2	; Is the source position, at, or below the cursor index?
-	beq @inc_loop1	; Yes, so keep looping.
-	bcs @end	; No, so we're done.
-@inc_loop1:
-	ldy.w scr_ptr2	; Get the source position.
-	lda (ptr3), y	; Get the character from the source position.
-	phy.w		; Save the source position for later.
-	txy		; Set our position to the destination.
-	sta (ptr3), y	; Place the character from the source position, to the destination position.
-	ply.w		; Set our position back to the source.
-	stb (ptr3), y	; Clear the character that is in the source.
-	bng @minus	; The source underflowed, so set it back to zero,
-	dey		; Decrement the source position.
-	dex		; Decrement the destination position.
-	bra @inc_loop	; Keep looping.
-@dec_loop:
-	stx.w scr_ptr2	; Save the destination position for later.
-	lda (ptr3), y	; Is the character at the source position, a null terminator?
-	beq @end3	; Yes, so we're done.
-	phy.w		; No, so save the source position for later.
-	txy		; Set our position to the destination.
-	sta (ptr3), y	; Place the character from the source position, to the destination position.
-	inx		; Increment the destination position.
-	ply.w		; Set our position back to the source.
-	stb (ptr3), y	; Clear the character that is in the source.
-	iny		; Increment the source position.
-	bra @dec_loop	; Keep looping.
+	and #0			; Set the source poition to 0.
+	mov (d), a		; Clear the character that is in the source.
+	bra @lend		; We are done.
+@left:
+	cmp s, a		; Is the cursor index, at, or below the source position?
+	beq @left1		; Yes, so keep looping.
+	bcs @lend		; No, so we're done.
+@left1:
+	cmp #0			; Is the source position less than 0?
+	bcc @minus		; Yes, so set the source position to zero.
+	mov (d+a+1), (d+a)	; No, so shift the current character to the left by one.
+	mov (d+a), #0		; Clear the current character.
+	dec			; Decrement the source position.
+	bra @left		; Keep looping.
+@right:
+	cmp (d+s), #0		; Is this character a null terminator?
+	beq @rend		; Yes, so we're done.
+	mov (d+s-1), (d+s)	; No, so shift the current character to the right by one.
+	mov (d+s), #0		; Clear the current character.
+	inc s			; Increment the source position.
+	bra @right		; Keep looping.
 @wrap:
-	tax		; Use the ending line as a parameter for setbit.
-	jsr setbit	; Set the wrap bit of the ending line.
-	bra @end5	; We are done.
+	mov d, a		; Get the ending line.
+	jsr setbit		; Set the wrap bit of the ending line.
+	bra @end		; We are done.
 @wrap1:
-	tax		; Use the ending line as a parameter for clrbit.
-	jsr clrbit	; Clear the wrap bit of the ending line.
-	bra @end5	; We are done.
+	mov d, a		; Get the ending line.
+	jsr clrbit		; Clear the wrap bit of the ending line.
+	bra @end		; We are done.
+@lend:
+	lea s, (a+2)		; Add 2 to the source position.
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the end of line position.
+	div #maxcol+1		; Get the ending line.
+@lend2:
+	cmp scr_row		; Is the ending line greater than the starting line?
+	beq @end		; No, so we're done.
+	bcs @wrap		; Yes, so set the wrap bit.
+	bra @end		; No, so we're done.
+@rend:
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the end of line position.
+	div #maxcol+1		; Get the ending line.
+	cpb #0			; Is the remainder zero?
+	bne @end		; No, so we're done.
+@rend2:
+	cmp scr_row		; Is the ending line greater than the starting line?
+	beq @end		; No, so we're done.
+	bcs @wrap1		; Yes, so clear the wrap bit.
 @end:
-	lda (ptr3), y	; Is this character a null terminator?
-	bne @end1	; No, so just find the end of the line.
-	lda #$20	; Yes, so convert it to a space for now.
-	sta (ptr3), y	;
-@end1:
-	jsr findend	; Find the ending line.
-	sta regd	; Save ending line for later.
-	lda (ptr3), y	; Is this character a space?
-	cmp #$20	;
-	bne @end5	; No, so skip the conversion.
-	lda #0		; Yes, so convert it back to zero.
-	sta (ptr3), y	;
-@end2:
-	lda regd	; Get the ending line.
-	cmp scr_row	; Is the ending line greater than the starting line?
-	beq @end5	; No, so we're done.
-	bcs @wrap	; Yes, so set the wrap bit.
-	bra @end5	; No, so we're done.
-@end3:
-	jsr findend	; Find the ending line.
-	cpb #0		; Is the remainder zero?
-	beq @end4	; Yes, so check if the ending line is greater than the starting line.
-	bra @end5	; No, so we're done.
-@end4:
-	cmp scr_row	; Is the ending line greater than the starting line?
-	beq @end5	; No, so we're done.
-	bcs @wrap1	; Yes, so clear the wrap bit.
-@end5:
-	rts		; End of shftln.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of shftln.
 
 
 esc:
@@ -883,8 +811,10 @@ isright:
 	bra @right	; No, so move the cursor right, like normal.
 @wrap:
 	inc scr_row	; Move down a row.
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is the current line, a wrapped line?
-	bcs @incr	; Yes, so leave the cursor where it is.
+	bne @incr	; Yes, so leave the cursor where it is.
 	dec scr_row	; No, so move the cursor back up a row.
 	bra @end2	; We are done.
 @scroll:
@@ -927,8 +857,10 @@ isleft:
 	beq @left	; Yes, so move the cursor left.
 	bra @end1	; No, so we're done.
 @wrap:
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is the current line, a wrapped line?
-	bcs @decr	; Yes, so wrap back up a line.
+	bne @decr	; Yes, so wrap back up a line.
 	bra @end1	; No, so we're done.
 @decr:
 	lda scr_row	; Is the cursor at the top of the screen?
@@ -999,12 +931,11 @@ isshftdown:
 
 
 update_ptr:
-	clc		; Clear the carry flag.
 	lda scr_row	; Add the cursor's line number,
-	adc scr_str	; with the starting line number to get the absolute line number.
+	add scr_str	; with the starting line number to get the absolute line number.
 	mul #maxcol+1	; Multiply the line number by the screen's max column count, plus 1.
-	clc		; Clear the carry flag.
-	adc scr_col	; Add the cursor's column number to get the screen index.
+	add scr_col	; Add the cursor's column number to get the screen index.
+	sta.w scr_ptr	; Save the screen index.
 ;	cmp.w #$2000	; Is the index greater than, or equal to the end of the screen buffer?
 ;	bcc @end	; No, so we're done.
 ;@wrap:
@@ -1021,22 +952,21 @@ update_ptr:
 
 
 update_pos:
+	phb.q		; Preserve B.
+	and #0		; Reset A.
+	tab		; Reset B.
 	ldb #1		; Set the F pseudo register to one, to fix some bugs.
 	stb regf	;
 	jsr update_ptr	; Update the screen buffer index.
 	tay		; Place the index into the Y register.
 	tba		; Reset A.
-	lda #$1B	; Print an escape character
-	sta scr		; to the screen.
-	lda #'['	; Print '['
-	sta scr		; to the screen, and start the escape sequence.
+	mov scr, #$1B	; Print an escape character to the screen.
+	mov scr, #'['	; Print '[' to the screen, and start the escape sequence.
 	jsr getrow	; Start printing the row number to the screen.
-	lda #';'	; Print ';'
-	sta scr		; to the screen.
+	mov scr, #';'	; Print ';' to the screen.
 	jsr getcol	; Start printing the column number to the screen.
-	lda #'H'	; Print 'H'
-	sta scr		; to the screen.
-	;inc step	;
+	mov scr, #'H'	; Print 'H' to the screen.
+	plb.q		; Restore B.
 	rts		; End of update_pos.
 
 getrow:
@@ -1068,6 +998,7 @@ scrl_down:
 	lda wrapped	; Was the wrapped flag set?
 	beq @save	; Yes, so save the cursor position.
 @redraw:
+	lea d, (buffer)	; Get the screen buffer.
 	jsr rdrw_row	; No, so redraw this row.
 	lda wrapped	; Was the wrapped flag set?
 	beq @load	; Yes, so load the previous cursor position back.
@@ -1103,6 +1034,7 @@ scrl_up:
 	pha 		;
 	lda #0		;
 	sta scr_row	;
+	lea d, (buffer)	; Get the screen buffer.
 	jsr rdrw_row	;
 	pla 		;
 	sta scr_col	;
@@ -1112,64 +1044,54 @@ scrl_up:
 @end:
 	rts		;
 
+
 rdrw_row:
-	lda #0		;
-	sta scr_col	;
-	jsr update_pos	;
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
+	stz scr_col	; Reset the column position.
+	jsr update_pos	; Update the cursor position.
+	xor b, b	; Reset B.
+	tya		; Get the screen index.
+	tab		;
+	add b, #maxcol+1; Get the end of the row plus one.
 @loop:
-	lda (ptr3), y	;
-	beq @incr	;
-	sta scr		;
-@incr:
-	inc scr_col	;
-	lda (ptr3), y	;
-	beq @skip	;
-@incr1:
-	iny		;
-@incr2:
-	lda scr_col	;
-	cmp #maxcol+1	;
-	bcs @end	;
-	bra @loop	;
-@skip:
-	lda #' '	;
-	sta scr		; to the screen.
-	bra @incr1	;
+	cmp (d+a), #0	; Is this a null terminator?
+	mne scr, (d+a)	; No, so print the character.
+	meq scr, #' '	; Yes, so print a space.
+	inc		; Increment the screen index.
+	cmp b		; Is the column position at, or above the maximum column count?
+	bcc @loop	; No, so keep looping.
 @end:
-	lda #0		;
-	sta scr_col	;
-	jsr update_pos	;
-@end1:
-	rts		;
+	stz scr_col	; Reset the column position.
+	jsr update_pos	; Update the cursor position.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of rdrw_row.
+
 
 rdrw_ln:
-	lda scr_row	;
-	pha 		;
-	lda regf	;
-	sta scr_row	;
-	lda scr_col	;
-	pha 		;
-	jsr update_pos	;
+	pha.q		; Preserve A.
+	psh scr_row	; Preserve the row position.
+	psh scr_col	; Preserve the column position.
+	mov scr_row, s	; Set the row position to the starting position.
+	jsr update_pos	; Update the cursor position.
+	mov a, d	; Get the ending position.
+	lea d, (buffer)	; Get the address of the screen buffer.
 @loop:
-	lda scr_row	;
-	cmp rege	;
-	beq @loop1	;
-	bcs @end	;
-@loop1:
-	jsr rdrw_row	;
+	cmp scr_row, a	; Is the row position at, or below the ending position?
+	beq @redraw	; Yes, so redraw the row.
+	bcs @end	; No, so we're done.
+@redraw:
+	jsr rdrw_row	; Redraw the line.
 @incr:
-	inc scr_row	;
-	bra @loop	;
+	inc scr_row	; Increment the row position.
+	bra @loop	; Keep looping
 @end:
-	pla 		;
-	sta scr_col	;
-	pla 		;
-	sta scr_row	;
-	jsr update_pos	;
-	lda #0		;
-	sta rege	;
-	sta regf	;
-	rts		;
+	pul scr_col	; Restore the column position.
+	pul scr_row	; Restore the row position.
+	jsr update_pos	; Update the cursor position.
+	pla.q 		; Restore A.
+	rts		; End of rdrw_ln.
 
 
 set_ptr:
diff --git a/programs/sub-suite/test-size.s b/programs/sub-suite/test-size.s
new file mode 100644
index 0000000..b543a36
--- /dev/null
+++ b/programs/sub-suite/test-size.s
@@ -0,0 +1,59 @@
+MAGIC = $AA
+
+
+.org 0
+findramend:
+	and #0		; Reset A.
+;	lda #MAGIC	; Set A to a magic number.
+@loop:
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
+	bne @moveback	; No, so move back until we find the last writable memory location.
+	mov (d), a	; Yes, so restore the previous value.
+	add.w d, #$4000	; Increment the end of RAM pointer by 16K.
+	bra @loop	; Keep looping.
+@moveback:
+	dec d		; Decrement the end of RAM pointer.
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
+	bne @moveback	; No, so keep looping.
+	mov (d), a	; Yes, so restore the previous value.
+@end:
+	mov a, d	; Return the end of RAM pointer.
+;	ple.q		; Restore E.
+	rts		; End of findramend.
+
+
+;findramend:
+;	phe.q		; Preserve E.
+;	phb.q		; Preserve B.
+;	mov e, d	; Set E to the RAM pointer.
+;	and #0		; Reset A.
+;	lda #MAGIC	; Set A to a magic number.
+;@loop:
+;	ldb (e)		; Preserve the value.
+;	sta (e)		; Write the magic number to the current end of RAM.
+;	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+;	bne @moveback	; No, so move back until we find the last writable memory location.
+;	stb (e)		; Yes, so restore the previous value.
+;	ade.w #$4000	; Increment the end of RAM pointer by 16K.
+;	bra @loop	; Keep looping.
+;@moveback:
+;	dee		; Decrement the end of RAM pointer.
+;	ldb (e)		; Preserve the value.
+;	sta (e)		; Write the magic number to the current end of RAM.
+;	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+;	bne @moveback	; No, so keep looping.
+;	stb (e)		; Yes, so restore the previous value.
+;@end:
+;	mov a, e	; Return the end of RAM pointer.
+;	ple.q		; Restore E.
+;	plb.q		; Restore B.
+;	rts		; End of findramend.
+
+a
+.org findramend
+v
+q
diff --git a/programs/sub-suite/utils.s b/programs/sub-suite/utils.s
index 3813a05..6479099 100644
--- a/programs/sub-suite/utils.s
+++ b/programs/sub-suite/utils.s
@@ -1,141 +1,125 @@
 ; Utility subroutines for SuBAsm.
 
 print_hi:
-	and #0		; Reset A.
-	sta idx3	; Clear the string index.
-	tax		; Reset X.
-	lda #'$'	; Print the hex delimiter.
-	sta strbuf, x	; Save it in the string buffer.
-	lda.q idx0	; Get the masked address.
-	ldx #$10	; Set digit count to 16.
-	jsr print_hex	; Print the address.
-	lda.q hex_str	; Get the lower half of the string.
-	sta.q strbuf+1	; Save it in the string buffer.
-	lda.q hex_str+8	; Get the upper half of the string.
-	sta.q strbuf+9	; Save it in the string buffer.
-	ldx #$11	; Add 16 to the index.
-	stx idx3	;
-	lda.w #': '	; Print a space.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	and #0		; Reset A.
-	rts		; End of print_hi.
+	phb.q			; Preserve B.
+	sbs #$10		; Make room for the hex string buffer.
+	and #0			; Reset A.
+	mov b, d		; Get the string buffer pointer.
+	mov (b), #'$'		; Print the hex delimiter to the string buffer.
+	inb			; Increment the string buffer pointer.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	mov f, #$10		; Set digit count to 16.
+	jsr print_hex		; Print the address.
+	mov.q (b), (a)		; Print the lower half of the hex string to the string buffer.
+	mov.q (b+8), (a+8)	; Print the upper half of the hex string to the string buffer.
+	add b, #$10		; Add 16 to the index.
+	mov.w (b), #': '	; Print a colon, and space to the string buffer.
+	add b, #2		; Add two to the string buffer pointer.
+	tba a			; Return the string buffer pointer after the printed string.
+	ads #$10		; Cleanup the stack frame.
+	plb.q			; Restore B.
+	rts			; End of print_hi.
 
 
 print_lo:
-	and #0		; Reset A.
-	sta idx3	; Clear the string index.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	sbs #$33		; Make room for the hex string buffer, and the normal string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	lea x, (sp+3)		; Get the address of the string buffer.
 @loop:
-	ldx #2		; Set digit count to 2.
-	pha		; Preserve the nibble offset.
-	jsr print_hex	; Print the low nibble offset.
-	lda.w (ptr3)	; Get the two digits.
-	ldx idx3	; Get the string index.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	ldx idx3	; Get the string index.
-	pla		; Get the nibble offset back.
-	inc		; Increment the offset.
-	cmp #$10	; Are we at the last offset?
-	bcs @end	; Yes, so we're done.
+	lea f, 2		; Set the digit count to two.
+	mov s, b		; Get the low nibble offset.
+	jsr print_hex		; Print the low nibble offset.
+	mov.w (x), (a)		; Place the hex digits in the string buffer.
+	add x, #2		; Add two to the string buffer pointer.
+	inb			; Increment the nibble offset.
+	cpb #$10		; Are we at the last offset?
+	bcs @end		; Yes, so we're done.
 @loop1:
-	pha		; No, so preserve the nibble offset.
-	lda #' '	; Add a space to the string buffer.
-	sta strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index.
-	pla		; Get the nibble offset back.
-	bra @loop	; Keep looping.
+	mov (x), #' '		; No, so add a space to the string buffer.
+	inx			; Increment the string buffer pointer.
+	bra @loop		; Keep looping.
 @end:
-	and #0		; Reset A.
-	sta strbuf, x	; Null terminate the string buffer.
-	tax		; Reset X.
-	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-	jsr print_sfast	; Use the faster, but less robust print string routine.
-	rts		; End of print_lo.
-;@end:
-;	lda #0		; Null terminate the string buffer.
-;	sta strbuf, x	;
-;	tax		; Reset X.
-;	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-;	rts		; End of print_lo.
+	mov (x), #0		; Null terminate the string buffer.
+	lea d, (sp+3)		; Get the address of the string buffer.
+	lea s, (buffer)+y	; Get the address of the screen buffer, at the current cursor position.
+;	jsr print_str		; Print the string buffer.
+	jsr print_sfast		; Use the faster, but less robust print string routine.
+	ads #$33		; Cleanup the stack frame.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of print_lo.
 
 
 print_chunk:
-	ldx #0		; Reset X.
-	phy.w		; Preserve the screen buffer index.
-	txy		; Copy the byte index to it.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	sbs #2			; Make room for the hex string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	mov x, d		; Get the address of the string buffer.
+	mov y, s		; Get the starting address.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	xor s, s		; Reset S.
 @loop:
-	and #0		; Reset A.
-	ldx #2		; Set the digit count to 2.
-	lda (idx0), y	; Get the byte at that address.
-	jsr print_hex	; Print the byte.
-	lda.w (ptr3)	; Get the two digits.
-	ldx idx3	; Get the string index.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	ldx idx3	; Get the string index.
-	iny		; Increment the byte index.
-	cpy #$10	; Have we read 16 bytes?
-	beq @end	; Yes, so we're done.
-	lda #' '	; No, so add a soace to the string buffer.
-	sta strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index.
-	bra @loop	; Keep looping.
+	lea f, 2		; Set the digit count to two.
+	mov s, (y+b)		; Get the byte at that address.
+	jsr print_hex		; Print the byte.
+	mov.w (x), (a)		; Print the hex string to the string buffer.
+	add x, #2		; Add two to the string buffer pointer.
+	inb			; Increment the byte index.
+	cpb #$10		; Have we read 16 bytes?
+	beq @end		; Yes, so we're done.
+	mov (x), #' '		; No, so print a space to the string buffer.
+	inx			; Increment the string buffer pointer.
+	bra @loop		; Keep looping.
 @end:
-	ply.w		; Get the screen buffer index back.
-	inx		; Increment the index by one.
-	and #0		; Null terminate the string.
-	sta strbuf, x	;
-	tax		; Reset X.
-	sta idx3	; Clear the string index.
-	rts		; End of print_chunk.
+	mov (x), #0		; Null terminate the string.
+	ads #2			; Cleanup the stack frame.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of print_chunk.
 
 
 print_hex:
-	pha.q		; Preserve the hex value.
-	and #0		; Reset A.
-	ldb #1		; Set the second pointer
-	lda.w #hex_char	; to the start of hex character table.
-	jsr set_ptr	;
-	inb		; Set the third pointer
-	lda.d #hex_str	; to the end of hex string buffer.
-	clc		; Do a non carrying add.
-	adc #$10	;
-	jsr set_ptr	;
-	ldb #0		; Reset B.
-	pla.q		; Get the hex value back.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
+	phy.q		; Preserve Y.
+	lea b, hex_char	; Get the address of the hex character table.
+	and f, f	; Is the digit count zero?
+	set x, eq	; Set the auto digit count flag if so.
+	mne f, #$10	; Also set the digit count to 16 if the digit count is zero.
+	mov a, f	; Get the digit count.
+	add a, d	; Add the string pointer with the digit count.
 @loop:
-	pha.q		; Preserve the hex value.
-	and #$F		; Mask the lowest nibble.
-	phy.w		; Preserve the screen buffer position.
-	tay		; Get the index for the hex digit.
-	lda (ptr2), y	; Get the hex digit.
-	dec ptr3	; Decrement the string pointer.
-	sta (ptr3)	; Save the hex digit character in the string.
-	ply.w		; Get back the screen buffer position.
-	pla.q		; Get the hex value back.
+	mov y, s	; No, so mask the low nibble of the value.
+	and y, #$F	;
+	dec		; Decrement the string pointer.
+	mov (a), (b+y)	; Place the hex digit character in the string.
+	lsr s, #4	; Is the next nibble zero?
+	bne @loop1	; No, so decrement the digit count.
 @isauto:
-	cpx #1		; Is the digit count less than one?
-	bcc @auto	; Yes, so don't decrement the digit count.
-	dex		; No, but was the digit count zero, when decremented?
-	beq @end	; Yes, so we're done.
-	bra @next	; No, so get the next nibble.
-@auto:
-	ldb #1		; Enable auto digit count.
-@next:
-	lsr #4		; Is the next nibble, a zero?
-	beq @isauto1	; Yes, so check if auto digit count is enabled.
-	bra @loop	; No, so print the next digit.
-@isauto1:
-	cpb #1		; Is auto digit count enabled?
-	beq @end	; Yes, so we're done.
-	bra @loop	; No, so keep printing more digits.
+	and x, x	; Is the auto digit count flag set?
+	bne @end	; Yes, so we're done.
+@loop1:
+	cpx #1		; Is the auto digit count flag set?
+	sbc f, #0	; Decrement the digit count if not.
+	mov y, f	; Get the digit count.
+	or  y, x	; Are both the digit count, and the auto digit count flag zero?
+	bne @loop	; No, so keep looping.
 @end:
+	ply.q		; Restore Y.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts		; End of print_hex.
 
 
@@ -147,26 +131,18 @@ charcpy:
 
 
 strcmpg:
-	ldb.w #strcmp	; Get the address of strcmp.
-	phb.q		; Use it for an indirect call.
-	ldb.q ptr	; Get the first pointer.
+	lea strcmp	; Get the address of strcmp.
+	mov.q d, ptr	; Get the first pointer.
 	bra gargs	; Jump to the argument handler.
 strcaseg:
-	ldb.w #strccmp	; Get the address of strcasecmp.
-	phb.q		; Use it for an indirect call.
-	ldb.q ptr	; Get the first pointer.
+	lea strcasecmp	; Get the address of strcasecmp.
+	mov.q d, ptr	; Get the first pointer.
 	bra gargs	; Jump to the argument handler.
 gargs:
-	phb.q		; Use the pointer in B as the first arg.
-	pha.q		; Use the value in A as the second arg.
-	and #0		; reset a.
-	tab		; reset b.
-	jsr (sp+17)	; call the pushed routine.
-	tab		; Preserve the return value.
-	pla.q		; Get the second arg back.
-	pla.q		; Get the first arg back.
-	pla.q		; Get the pushed routine back.
-	tba		; Get the return value back.
+	mov s, a	; Use the value in A as the second arg.
+	and #0		; Reset a.
+	tab		; Reset b.
+	jsr (e)		; Call the pushed routine.
 	rts		; End of gargs.
 
 
@@ -310,11 +286,6 @@ get_ptok:
 
 
 get_ctrlidx:
-;	phe.q		; Preserve E.
-;	cmp #$7F	; Is this a delete character?
-;	beq @del	; Yes, so return the same value as backspace.
-;	sec		; Do a non borrowing subtract.
-;	sbc #8		; Subtract 8 from the character, to get the index.
 	sub #8		; Subtract 8 from the character, to get the index.
 	tax		; Copy the index to X.
 	and #0		; Reset A.
@@ -324,62 +295,41 @@ get_ctrlidx:
 	leq (e)		;
 	cmp #$7F	; Is this a delete character?
 	leq #2		; Return 2 if this is the delete character.
-;	bcc @get_rtval	; Yes, so get the return value from the table.
-;	beq @get_rtval	;
-;	ple.q		; Restore E.
 	rts		; End of get_ctrlidx.
-;@get_rtval:
-;	lda ct_rtb, x	; Get the return value from the table.
-;	rts		; End of get_ctrlidx.
-;@del:
-;	lda #2		; Return 2.
-;	rts		; End of get_ctrlidx.
 
 
 findramend:
-	phx.q		; Preserve X.
 	and #0		; Reset A.
-	lda #MAGIC	; Set A to a magic number.
 @loop:
-	ldx (e)		; Preserve the value.
-	sta (e)		; Write the magic number to the current end of RAM.
-	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
 	bne @moveback	; No, so move back until we find the last writable memory location.
-	stx (e)		; Yes, so restore the previous value.
-	ade.w #$4000	; Increment the end of RAM pointer by 16K.
+	mov (d), a	; Yes, so restore the previous value.
+	add.w d, #$4000	; Increment the end of RAM pointer by 16K.
 	bra @loop	; Keep looping.
 @moveback:
-	dee		; Decrement the end of RAM pointer.
-	ldx (e)		; Preserve the value.
-	sta (e)		; Write the magic number to the current end of RAM.
-	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+	dec d		; Decrement the end of RAM pointer.
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
 	bne @moveback	; No, so keep looping.
-	stx (e)		; Yes, so restore the previous value.
+	mov (d), a	; Yes, so restore the previous value.
 @end:
-	phe.q		; Return the end of RAM pointer.
-	pla.q		;
-	plx.q		; Restore X.
+	mov a, d	; Return the end of RAM pointer.
 	rts		; End of findramend.
 
 
 print_sfast:
-;	inc step	;
-	pea (buffer), y	; Push the address of the cursor's postion in the screen buffer to the stack.
+	pha.q			; Preserve A.
+	and #0			; Reset A.
 @loop:
-	lda (e)		; Get the character.
-	beq @end	; We've hit the end of the string, so we're done.
-	cmp #'\n'	; Did we get a newline?
-	beq @nl		; Yes, so move the cursor to the next line.
-	sta (sp+1)	; Print the character to the screen buffer.
-	sta scr		; Print the character to the screen.
-	inc scr_col	; Move the cursor left by one character.
-	ine		; Increment the string pointer.
-	inc.q sp+1	; Increment the screen buffer pointer.
-	bra @loop	; Keep looping.
-@nl:
-	stz scr_col	; Move the cursor to the start of the line.
-	inc scr_row	; Move the cursor down by one line.
-	bra @loop	; Keep looping.
+	inc			; Increment the index.
+	cmp (d+a-1), #0		; Did we hit the end of the string?
+	beq @end		; Yes, so we're done.
+	mov (s+a-1), (d+a-1)	; No, so print the character to the buffer.
+	mov scr, (d+a-1)	; Print the character to the screen.
+	bra @loop		; Keep looping.
 @end:
-	ads #8		; Cleanup the stack frame.
-	rts		; End of print_sfast.
+	pla.q			; Restore A.
+	rts			; End of print_sfast.
diff --git a/supervia.c b/supervia.c
new file mode 100644
index 0000000..23e44e9
--- /dev/null
+++ b/supervia.c
@@ -0,0 +1,18 @@
+void init_supervia(struct supervia *sv) {
+	memset(sv, 0, sizeof(struct supervia));
+}
+
+/* Shifts out one bit from each output byte of the shift register into
+ * the serial output lines of those output bytes.
+ */
+void shift_out8(struct supervia *sv, int id) {
+	uint8_t bitpos = 7-sv->sr[id].ocount;
+	for (int i = 0; i < 8; i++) {
+		if (sv->sr[id].dir & (1 << i)) {
+			uint8_t bit = (sv->sr[id].data.u8[i] >> bitpos) & 1;
+			sv->sr[id].bits |= (bit << i);
+		}
+	}
+	sv->sr[id].ocount++;
+	sv->sr[id].ocount %= 8;
+}
diff --git a/supervia.h b/supervia.h
new file mode 100644
index 0000000..8afc45d
--- /dev/null
+++ b/supervia.h
@@ -0,0 +1,25 @@
+
+struct shift_reg {
+	union reg data;	/* Shift Register Data. */
+	uint8_t bits;	/* Serial data for each byte. */
+	uint8_t ocount;	/* Shift out counter. */
+	uint8_t icount;	/* Shift out counter. */
+	uint8_t dir;	/* Data direction for each byte. */
+};
+
+
+struct supervia {
+	union reg pa;		/* Port A. */
+	union reg pb;		/* Port B. */
+	union reg ddra;		/* Port A Data Direction Register. */
+	union reg ddrb;		/* Port B Data Direction Register. */
+	union reg t[4];		/* Timers 1-4. */
+	struct shift_reg sr[4];	/* Shift Registers A-D. */
+	union reg acr;		/* Auxiliary Control Register. */
+	union reg pcr;		/* Peripheral Control Register. */
+	union reg ifr;		/* Interrupt Flags Register. */
+	union reg ier;		/* Interrupt Enable Register. */
+	union reg rng[2];	/* Random Number Generator A, and B. */
+	union reg dac[2];	/* DAC A, and B. */
+	union reg adc[2];	/* ADC A, and B. */
+};
diff --git a/sux.c b/sux.c
index de88b92..59c2168 100644
--- a/sux.c
+++ b/sux.c
@@ -33,6 +33,7 @@ uint8_t step = 0;
 uint8_t *addr;
 
 uint8_t kbd_rdy;
+uint8_t dbg_print_per_inst = 0;
 
 uint8_t end = 0;
 
@@ -107,6 +108,21 @@ uint8_t is_extop(uint8_t opcode, uint8_t dbg) {
 	return 1;
 }
 
+int is_wait_kbd(struct sux *cpu, uint8_t opcode, uint8_t prefix, uint8_t ext_prefix, uint8_t prefix2, uint8_t *op_type, uint8_t *op_id, uint8_t op_len, uint8_t thread) {
+	uint64_t address = 0;
+	operand ortho_op[2];
+	uint64_t ortho_addr[2] = {0, 0};
+	uint64_t tmp_pc = cpu->pc;
+	cpu->pc += op_len;
+	if (ext_prefix != 0x1D) {
+		address = get_addr(cpu, opcode, prefix, ext_prefix, 0, 0, thread);
+	} else {
+		get_ortho_addr(cpu, prefix, cpu->pc, ortho_op, ortho_addr, op_type, op_id, 0, 0, thread);
+	}
+	cpu->pc = tmp_pc;
+	return (address == CTRL_ADDR || ortho_addr[0] == CTRL_ADDR || ortho_addr[1] == CTRL_ADDR);
+}
+
 void *run(void *args) {
 	struct suxthr *thr = (void *)args;
 	struct sux *cpu = &thr->sx;
@@ -169,19 +185,6 @@ void *run(void *args) {
 		#endif
 		address.u64 = 0;
 		value.u64 = 0;
-		#if debug && !bench
-		if (lines > 24*(thread+1)) {
-			lines = (24*thread)+2;
-		}
-		#if keypoll
-		pthread_mutex_lock(&mutex);
-		#endif
-		print_info(cpu, inst_win, lines, thread);
-		print_regs(cpu, regs);
-		#if keypoll
-		pthread_mutex_unlock(&mutex);
-		#endif
-		#endif
 		uint32_t inst = read_value(cpu, 0, cpu->pc, 4, 1, 0);
 		uint8_t *tmp_inst = (uint8_t *)&inst;
 		uint8_t inst_len = 0;
@@ -190,8 +193,6 @@ void *run(void *args) {
 		opcode = tmp_inst[inst_len++];
 		op_id = (ext_prefix == 0x1D) ? tmp_inst[inst_len++] : 0;
 
-		cpu->pc += inst_len;
-		address.u64 = cpu->pc;
 		uint8_t operand_type[2];
 		uint8_t am;
 		uint8_t ortho_id[2];
@@ -253,16 +254,34 @@ void *run(void *args) {
 		uint8_t rs   = (prefix >>  4) & 3;
 		uint8_t size = (/***/1 << rs) - 1;
 		uint8_t check_io = (am != IMM);
-	#if debug && !bench
-		#if keypoll
-		pthread_mutex_lock(&mutex);
-		#endif
-		disasm(cpu, inst_win, lines, opcode, prefix, ext_prefix, prefix2, operand_type, ortho_id, thread);
-		lines+=1;
-		#if keypoll
-		pthread_mutex_unlock(&mutex);
+		cpu->pc += inst_len;
+		address.u64 = cpu->pc;
+		#if debug && !bench
+		cpu->pc -= inst_len;
+		if (!dbg_print_per_inst) {
+			kbd_rdy = is_wait_kbd(cpu, opcode, prefix, ext_prefix, prefix2, operand_type, ortho_id, inst_len, thread);
+		} else {
+			kbd_rdy = 0;
+		}
+		if (lines > 24*(thread+1)) {
+			lines = (24*thread)+2;
+		}
+		if (step | kbd_rdy | dbg_print_per_inst) {
+			#if keypoll
+			pthread_mutex_lock(&mutex);
+			#endif
+			print_info(cpu, inst_win, lines, thread);
+			print_regs(cpu, regs);
+			cpu->pc = address.u64;
+			disasm(cpu, inst_win, lines, opcode, prefix, ext_prefix, prefix2, operand_type, ortho_id, thread);
+			lines+=1;
+			#if keypoll
+			pthread_mutex_unlock(&mutex);
+			#endif
+		} else {
+			cpu->pc = address.u64;
+		}
 		#endif
-	#endif
 		if (am != IMPL && am != BREG) {
 			address.u64 = get_addr(cpu, opcode, prefix, ext_prefix, 1, 1, thread);
 			/*if (address.u64 > mem_size-1) {
@@ -285,7 +304,7 @@ void *run(void *args) {
 		} else {
 			exec_base_inst(cpu, opcode, prefix, value.u64, address.u64, size, thread);
 		}
-		//usleep(1);
+		/*usleep(1);*/
 		#if !IO
 		ins++;
 		#endif
diff --git a/sux.h b/sux.h
index 9af8128..c028b84 100644
--- a/sux.h
+++ b/sux.h
@@ -22,6 +22,7 @@
 #define copy64 1
 
 extern uint8_t kbd_rdy;
+extern uint8_t dbg_print_per_inst;
 
 extern WINDOW *scr;
 extern WINDOW *regs;
@@ -292,6 +293,18 @@ static /*inline*/ uint8_t isread(uint8_t opcode, uint8_t ext_prefix) {
 	}
 }
 
+static int is_ind(uint8_t type) {
+	switch (type) {
+		case MEM_AIND :
+		case MEM_IND  :
+		case MEM_ARIND:
+		case MEM_ZRIND:
+		case MEM_AINDR:
+		case MEM_ZINDR: return 1;
+	}
+	return 0;
+}
+
 static void *memcopy(void *restrict dst, const void *restrict src, unsigned int n) {
 	#if copy64
 	uint64_t *d = dst;
@@ -510,7 +523,20 @@ static /*inline*/ uint64_t get_addr(struct sux *cpu, uint8_t opcode, uint8_t pre
 	return address;
 }
 
+static /*inline*/ uint64_t ortho_ind_addr(struct sux *cpu, uint8_t prefix, uint64_t address, uint8_t inc_clk) {
+	return read_value(cpu, 0, address, 7, inc_clk, 0);
+}
+
+static /*inline*/ uint64_t ortho_ind_idx_addr(struct sux *cpu, uint8_t prefix, uint64_t address, uint8_t inc_clk, uint64_t idx_reg, uint8_t pre_idx) {
+	if (pre_idx) {
+		return read_value(cpu, 0, address+idx_reg, 7, inc_clk, 0);
+	} else {
+		return ortho_ind_addr(cpu, prefix, address, inc_clk) + idx_reg;
+	}
+}
+
 static /*inline*/ uint64_t get_ortho_addr(struct sux *cpu, uint8_t prefix, uint64_t address, operand *op, uint64_t *value, uint8_t *op_type, uint8_t *op_id, uint8_t inc_pc, uint8_t inc_clk, uint8_t thread) {
+	uint64_t tmp_addr = address;
 	for (int i = 0; i < 2; i++) {
 		union reg tmp;
 		tmp.u64 = 0;
@@ -526,10 +552,8 @@ static /*inline*/ uint64_t get_ortho_addr(struct sux *cpu, uint8_t prefix, uint6
 			int is_rind = (op[i].id != MEM_ABS && op[i].id != MEM_ZM && op[i].id != MEM_AIND && op[i].id != MEM_IND && op[i].id != MEM_IMM);
 			if (is_rind) {
 				inst_size = (op[i].id == MEM_SIB)+1;
-				tmp.u64 = read_value(cpu, 0, address, inst_size-1, 0, 0);
-				if (inc_pc) {
-					address += inst_size;
-				}
+				tmp.u64 = read_value(cpu, 0, tmp_addr, inst_size-1, 0, 0);
+				tmp_addr += inst_size;
 				op[i].rind[0] = (tmp.u8[inst_size-1] & 0x0F);
 				op[i].rind[1] = (tmp.u8[inst_size-1] >> 4);
 				if (op[i].rind[1] == op[i].rind[0]) {
@@ -539,18 +563,15 @@ static /*inline*/ uint64_t get_ortho_addr(struct sux *cpu, uint8_t prefix, uint6
 			}
 			if (addr_size != 0xFF) {
 				inst_size = addr_size+1;
-				op[i].value = read_value(cpu, 0, address, inst_size-1, inc_clk, 0);
+				op[i].value = read_value(cpu, 0, tmp_addr, inst_size-1, inc_clk, 0);
 				value[i] = op[i].value;
-				if (inc_pc) {
-					address += inst_size;
-				}
+				tmp_addr += inst_size;
 			}
 			if (rs && op[i].id == MEM_IMM) {
-				value[i] = address;
-				if (inc_pc) {
-					address += rs;
-				}
+				value[i] = tmp_addr;
+				tmp_addr += rs;
 			}
+			uint64_t tmp_val = 0;
 			if (is_rind) {
 				for (int j = 0; j < 2 && op[i].rind[j] != 0xFF; j++) {
 					uint64_t reg;
@@ -572,17 +593,42 @@ static /*inline*/ uint64_t get_ortho_addr(struct sux *cpu, uint8_t prefix, uint6
 						case REG_R14: reg = cpu->r14;	break;
 						case REG_R15: reg = cpu->r15;	break;
 					}
-					value[i] += reg;
+					tmp_val += reg;
 				}
 				if (op[i].id == MEM_SIB) {
-					value[i] *= op[i].scale+1;
+					tmp_val *= op[i].scale+1;
+				} else if (addr_size != 0xFF) {
+					switch (addr_size) {
+						case 0: value[i] = (int8_t )value[i]; break;
+						case 1: value[i] = (int16_t)value[i]; break;
+						case 2:
+						case 3: value[i] = (int32_t)value[i]; break;
+						case 4:
+						case 5:
+						case 6:
+						case 7: value[i] = (int64_t)value[i]; break;
+					}
 				}
+				value[i] += (!is_ind(op[i].id)) ? tmp_val : 0;
 				#if getclk
 				cpu->clk += inc_clk;
 				#endif
 			}
+			if (is_ind(op[i].id)) {
+				uint8_t pre_idx = 0;
+				uint8_t type = op[i].id;
+				switch (type) {
+					case MEM_AIND :
+					case MEM_IND  : value[i] = ortho_ind_addr(cpu, prefix, value[i], inc_clk); break;
+					case MEM_ARIND:
+					case MEM_ZRIND: pre_idx = 1; /* Falls through. */
+					case MEM_AINDR:
+					case MEM_ZINDR: value[i] = ortho_ind_idx_addr(cpu, prefix, value[i], inc_clk, tmp_val, pre_idx); break;
+				}
+			}
 		}
 	}
+	address = (inc_pc) ? tmp_addr : address;
 	return address;
 }
 
@@ -859,6 +905,11 @@ static /*inline*/ uint64_t mov(struct sux *cpu, uint64_t src, uint64_t size, uin
 	return dst;
 }
 
+static /*inline*/ uint64_t cmov(struct sux *cpu, uint64_t src, uint64_t size, uint64_t dst, int flag, int *allow_io, uint8_t thread) {
+	*allow_io = flag;
+	return (flag) ? mov(cpu, src, size, thread) : dst;
+}
+
 static /*inline*/ uint64_t set(struct sux *cpu, uint8_t flag, uint8_t thread) {
 	setflag(flag == 0, Z);
 	return (flag != 0);
@@ -908,10 +959,30 @@ static /*inline*/ void exec_ortho_inst(struct sux *cpu, uint8_t opcode, uint8_t
 	uint64_t rem = 0;
 	uint64_t address[2] = {0, 0};
 	int isdiv = 0;
+	int allow_io[2] = {1, 1};
+	int is_lea = ((opcode & ~0x18) == LEA_RR);
+	int is_write = 1;
 	operand op[2];
 	cpu->pc = get_ortho_addr(cpu, prefix, cpu->pc, op, address, op_type, op_id, 1, 1, thread);
+	for (int i = 0; i < 2; i++) {
+		if (op[i].type) {
+			if (is_lea) {
+				switch (op[i].id) {
+					case MEM_RIND:
+					case MEM_ABS :
+					case MEM_ZM  :
+					case MEM_ABSR:
+					case MEM_ZMR :
+					case MEM_SIB :
+					case MEM_IMM : allow_io[i] = 0; break;
+				}
+			} else {
+				allow_io[i] = (op[i].id != MEM_IMM);
+			}
+		}
+	}
 	if (op[1].type) {
-		src = read_value(cpu, 0, (op[1].id != MEM_IMM) ? op[1].value : address[1], size, 1, 1);
+		src = read_value(cpu, 0, address[1], size, 1, allow_io[1]);
 	} else {
 		switch (op[1].id) {
 			case REG_A  : src = cpu->a;	break;
@@ -934,7 +1005,7 @@ static /*inline*/ void exec_ortho_inst(struct sux *cpu, uint8_t opcode, uint8_t
 	}
 	if (op[0].type) {
 		if (op[0].id != MEM_IMM) {
-			dst = read_value(cpu, 0, op[0].value, size, 1, 1);
+			dst = read_value(cpu, 0, address[0], size, 1, allow_io[0]);
 		}
 	} else {
 		switch (op[0].id) {
@@ -957,47 +1028,15 @@ static /*inline*/ void exec_ortho_inst(struct sux *cpu, uint8_t opcode, uint8_t
 		}
 	}
 	switch (opcode) {
-		case ORTHO_2OP(MNG):
-			if (getflag(N)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MPO):
-			if (!getflag(N)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MCS):
-			if (getflag(C)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MCC):
-			if (!getflag(C)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MEQ):
-			if (getflag(Z)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MNE):
-			if (!getflag(Z)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MVS):
-			if (getflag(V)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MVC):
-			if (!getflag(V)) {
-				dst = mov(cpu, src, size, thread);
-			}
-			break;
-		case ORTHO_2OP(MOV): dst = mov(cpu, src, size, thread); break;
+		case ORTHO_2OP(MNG): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst,  getflag(N), &allow_io[0], thread); break;
+		case ORTHO_2OP(MPO): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst, !getflag(N), &allow_io[0], thread); break;
+		case ORTHO_2OP(MCS): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst,  getflag(C), &allow_io[0], thread); break;
+		case ORTHO_2OP(MCC): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst, !getflag(C), &allow_io[0], thread); break;
+		case ORTHO_2OP(MEQ): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst,  getflag(Z), &allow_io[0], thread); break;
+		case ORTHO_2OP(MNE): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst, !getflag(Z), &allow_io[0], thread); break;
+		case ORTHO_2OP(MVS): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst,  getflag(V), &allow_io[0], thread); break;
+		case ORTHO_2OP(MVC): dst = cmov(cpu, src, (op[0].type) ? size : 7, dst, !getflag(V), &allow_io[0], thread); break;
+		case ORTHO_2OP(MOV): dst = mov(cpu, src, (op[0].type) ? size : 7, thread); break;
 		case ORTHO_2OP(ADC): dst = adc(cpu, dst,  src, getflag(C), (op[0].type) ? size+1 : 8, thread); break;
 		case ORTHO_2OP(SBC): dst = adc(cpu, dst, ~src, getflag(C), (op[0].type) ? size+1 : 8, thread); break;
 		case ORTHO_2OP(ADD): dst = adc(cpu, dst,  src, 0, (op[0].type) ? size+1 : 8, thread); break;
@@ -1012,34 +1051,35 @@ static /*inline*/ void exec_ortho_inst(struct sux *cpu, uint8_t opcode, uint8_t
 		case ORTHO_2OP(ASR): dst = asr(cpu, dst,  src, (op[0].type) ? size+1 : 8, thread); break;
 		case ORTHO_2OP(MUL): dst = mul(cpu, dst, src, (op[0].type) ? size+1 : 8, thread); break;
 		case ORTHO_2OP(DIV): dst = divd(cpu, dst, src, &rem, (op[0].type) ? size+1 : 8, thread); isdiv = 1; break;
-		case ORTHO_2OP(CMP): adc(cpu, dst, ~src, 1, (op[0].type) ? size+1 : 8, thread); break;
+		case ORTHO_2OP(CMP): adc(cpu, dst, ~src, 1, (op[0].type) ? size+1 : 8, thread); is_write = 0; break;
 		case ORTHO_2OP(PCN): dst = popcnt(cpu, src, thread); break;
 		case ORTHO_2OP(IML): dst = imul(cpu, dst, src, (op[0].type) ? size+1 : 8, thread); break;
 		case ORTHO_2OP(IDV): dst = idiv(cpu, dst, src, &rem, (op[0].type) ? size+1 : 8, thread); isdiv = 1; break;
 		case ORTHO_2OP(LEA):
 			do {
-				uint64_t address;
+				uint64_t tmp_addr;
 				uint64_t mask;
 				if (op[1].type) {
 					uint8_t addr_size = get_ortho_addrsize(prefix, op[1].id);
-					size = (!size) ? addr_size : size;
-					address = op[1].value;
+					size = (!size) ? 7 : size;
+					tmp_addr = address[1];
 				} else {
-					address = src;
+					tmp_addr = src;
 				}
 				mask = (-(uint64_t)1 >> ((7 - size) * 8));
-				dst = (address & mask);
+				dst = (tmp_addr & mask);
 			} while (0);
 			break;
 		case ORTHO_1OP(PEA):
 			do {
-				uint64_t address = (op[0].type) ? op[0].value : dst;
-				push(cpu, address, 7, thread);
+				uint64_t tmp_addr = (op[0].type) ? address[0] : dst;
+				push(cpu, tmp_addr, 7, thread);
+				is_write = 0;
 			} while (0);
 			break;
 		case ORTHO_1OP(INC): dst = inc_dec(cpu, dst, (op[0].type) ? size+1 : 8, 1, thread); break;
 		case ORTHO_1OP(DEC): dst = inc_dec(cpu, dst, (op[0].type) ? size+1 : 8, 0, thread); break;
-		case ORTHO_1OP(PSH): push(cpu, dst, size, thread); break;
+		case ORTHO_1OP(PSH): push(cpu, dst, size, thread); is_write = 0; break;
 		case ORTHO_1OP(PUL): dst = pull(cpu, size, thread); break;
 		case ORTHO_1OP(NOT): dst = ~dst; break;
 		case ORTHO_1OP(CLZ): dst = lbcnt(cpu, src, 0, size, thread); break;
@@ -1056,34 +1096,36 @@ static /*inline*/ void exec_ortho_inst(struct sux *cpu, uint8_t opcode, uint8_t
 		case ORTHO_1CC(SET, VC): dst = set(cpu, !getflag(V), thread); break;
 
 	}
-	if (op[0].type) {
-		if (op[0].id != MEM_IMM) {
-			write_value(cpu, dst, op[0].value, size, 1, 1);
-		}
-	} else {
-		switch (op[0].id) {
-			case REG_A  : cpu->a	= dst;	break;
-			case REG_B  : cpu->b	= dst;	break;
-			case REG_X  : cpu->x	= dst;	break;
-			case REG_Y  : cpu->y	= dst;	break;
-			case REG_E  : cpu->e	= dst;	break;
-			case REG_C  : cpu->c	= dst;	break;
-			case REG_D  : cpu->d	= dst;	break;
-			case REG_S  : cpu->s	= dst;	break;
-			case REG_F  : cpu->f	= dst;	break;
-			case REG_SP : cpu->sp	= dst;	break;
-			case REG_BP : cpu->bp	= dst;	break;
-			case REG_R11: cpu->r11	= dst;	break;
-			case REG_R12: cpu->r12	= dst;	break;
-			case REG_R13: cpu->r13	= dst;	break;
-			case REG_R14: cpu->r14	= dst;	break;
-			case REG_R15: cpu->r15	= dst;	break;
+	if (is_write) {
+		if (op[0].type) {
+			if (op[0].id != MEM_IMM) {
+				write_value(cpu, dst, address[0], size, 1, allow_io[0]);
+			}
+		} else {
+			switch (op[0].id) {
+				case REG_A  : cpu->a	= dst;	break;
+				case REG_B  : cpu->b	= dst;	break;
+				case REG_X  : cpu->x	= dst;	break;
+				case REG_Y  : cpu->y	= dst;	break;
+				case REG_E  : cpu->e	= dst;	break;
+				case REG_C  : cpu->c	= dst;	break;
+				case REG_D  : cpu->d	= dst;	break;
+				case REG_S  : cpu->s	= dst;	break;
+				case REG_F  : cpu->f	= dst;	break;
+				case REG_SP : cpu->sp	= dst;	break;
+				case REG_BP : cpu->bp	= dst;	break;
+				case REG_R11: cpu->r11	= dst;	break;
+				case REG_R12: cpu->r12	= dst;	break;
+				case REG_R13: cpu->r13	= dst;	break;
+				case REG_R14: cpu->r14	= dst;	break;
+				case REG_R15: cpu->r15	= dst;	break;
+			}
 		}
 	}
 	if (isdiv) {
 		if (op[1].type) {
-			if (op[0].id != MEM_IMM) {
-				write_value(cpu, dst, op[1].value, size, 1, 1);
+			if (op[1].id != MEM_IMM) {
+				write_value(cpu, src, address[1], size, 1, 1);
 			}
 		} else {
 			switch (op[1].id) {
diff --git a/test/ortho.s b/test/ortho.s
index 312c8eb..c7cdd83 100644
--- a/test/ortho.s
+++ b/test/ortho.s
@@ -4,6 +4,10 @@ count:
 .org $40000
 mem:
 	.res 256
+bitabl:
+	.res 8
+bits:
+	.res 8
 
 .org $8000
 reset:
@@ -18,6 +22,16 @@ reset:
 	cmp.qo (count), y
 	lea.o (count), y
 	lea mem
+	nop
+	lea d, $2000
+	nop
+	lea d, (mem+d)
+	lea bitabl, mem
+;	mov (bitabl)+a, 0
+	mov (d-128), #0
+	lea s, count
+	mov (e), #0
+	mov a, (e)
 loop:
 	inc b
 	inc.q count
@@ -31,7 +45,7 @@ loop:
 .qword reset
 
 a
-;.org reset
-;v
-;q
+.org reset
+v
+q
 d