stdlib.txt

def io_draw(var charcode, var x, var y) {
	asm {
		#load 1 r0;
		#load 2 r1;
		#load 3 r2;
		#draw r0 r1 r2;
	};
}

var io_x = 0;
var io_y = 0;

def io_cr();
def io_wait();

def io_clear() {
	var i = 0;
	while (i < 52) {
		var j = 0;
		while (j < 28) {
			asm {
				#load 2 r0;
				#load 1 r1;
				#literal " " r2;
				#draw r2 r0 r1;
			};
			j = j + 1;
		}
		i = i + 1;
	}
	io_x = 0;
	io_y = 0;
}

def io_normalize(var n) {
	if (io_x > 52 - n) {
		io_x = 0;
		io_y = io_y + 1;
	}
	if (io_y > 28 - 1) {
		io_y = 26;
		io_cr();
		io_y = 25;
		io_cr();
		io_y = 24;
		io_wait();
		io_clear();
	}
}

def io_putchar(var ch) {
	io_normalize(1);
	var x = io_x;
	var y = io_y;
	asm {
		#load 3 r0;
		#load 2 r1;
		#load 1 r2;
		#draw r0 r1 r2;
	};
	io_x = io_x + 1;
}

def io_readchar() {
	io_normalize(1);
	var x = io_x;
	var y = io_y;
	var z = asm {
		#load 3 r0;
		#load 2 r1;
		#keyboard r0 r1 r13;
	};
	io_x = io_x + 1;
	z;
}

def io_puthex(var ch) {
	io_normalize(4);
	var x = io_x;
	var y = io_y;
	asm {
		#load 3 r0;
		#load 2 r1;
		#load 1 r2;
		#printhex r0 r1 r2;
	};
	io_x = io_x + 4;
}

def io_readhex() {
	io_normalize(4);
	var x = io_x;
	var y = io_y;
	var z = asm {
		#load 3 r0;
		#load 2 r1;
		#keyhex r0 r1 r13;
	};
	io_x = io_x + 4;
	z;
}

def io_putdec(var ch) {
	io_normalize(4);
	var x = io_x;
	var y = io_y;
	asm {
		#load 3 r0;
		#load 2 r1;
		#load 1 r2;
		#printdec r0 r1 r2;
	};
	io_x = io_x + 4;
}

def io_readdec() {
	io_normalize(4);
	var x = io_x;
	var y = io_y;
	var z = asm {
		#load 3 r0;
		#load 2 r1;
		#keydec r0 r1 r13;
	};
	io_x = io_x + 4;
	z;
}

def io_cr() {
	io_x = 0;
	var i = 0;
	while (i < 28) {
		io_putchar(' ');
		i = i + 1;
	}
	io_x = 0;
}

def io_endl() {
	io_x = 255;
	io_normalize(0);
}

def io_wait() {
	io_endl();
	io_endl();
	echo "press any key to continue";
	io_readchar();
}

def error(var code) {
	asm {
		#load 1 r0;
		#output r0;
		#die;
	};
}

def heap_get(var address) {
	asm {
		#load 1 r0;
		#unheap r0 r13;
	};
}

def heap_set(var address, var value) {
	asm {
		#load 1 r0;
		#load 2 r1;
		#heap r1 r0;
	};
	value;
}

def malloc(var n) {
	var i = asm {
		#literal 0 r0;
		#unheap r0 r13;
	};
	var ret = 0;
	var break_i = 0;
	while (!break_i && i < 1024) {
		var x = heap_get(i);
		if (x == 0) {
			i = i + 2;
			var j = 0;
			var ok = 1;
			var break_j = 0;
			while (!break_j && j < n) {
				if (heap_get(i + j) == 0) {
					j = j + 1;
				} else {
					ok = 0;
					break_j = 1;
				}
			}
			if (ok == 1) {
				heap_set(i - 2, 1);
				heap_set(i - 1, n);
				ret = i;
				break_i = 1;
			} else {
				i = i + j;
			}
		} else {
			i = i + 2 + heap_get(i + 1);
		}
	}
	if (i > 1024 - 1) {
		error(3);
	}
	ret;
}

def free(var address) {
	var n = heap_get(address - 1);
	var i = address - 2;
	while (i < address + n) {
		heap_set(i, 0);
		i = i + 1;
	}
}

def vector_new(var n) {
	var pt = malloc(3);
	var array = malloc(n);
	heap_set(pt, array);
	heap_set(pt + 1, n);
	heap_set(pt + 2, 0);
	pt;
}

def vector_delete(var pt) {
	free(heap_get(pt));
	free(pt);
}

def vector_get(var pt, var i) {
	heap_get(heap_get(pt) + i);
}

def vector_set(var pt, var i, var x) {
	heap_set(heap_get(pt) + i, x);
}

def vector_size(var pt) {
	heap_get(pt + 2);
}

def vector_normalize(var pt) {
	var alloc_prev = heap_get(pt + 1);
	if (alloc_prev == vector_size(pt)) {
		var size_prime = alloc_prev + 4;
		var array_prime = malloc(size_prime);
		var array = heap_get(pt);
		var i = 0;
		while (i < alloc_prev) {
			heap_set(array_prime + i, heap_get(array + i));
			i = i + 1;
		}
		free(array);
		heap_set(pt, array_prime);
		heap_set(pt + 1, size_prime);
	}
}

def vector_push(var pt, var x) {
	vector_normalize(pt);
	var size = vector_size(pt);
	vector_set(pt, size, x);
	heap_set(pt + 2, size + 1);
}

def vector_pop(var pt) {
	var next_size = vector_size(pt) - 1;
	var x = vector_get(pt, next_size);
	heap_set(pt + 2, next_size);
	x;
}

def mergesort(var pt) {
	var size = vector_size(pt);
	if (size < 2) {
		var cp = vector_new(2);
		var i = 0;
		while (i < size) {
			vector_push(cp, vector_get(pt, i));
			i = i + 1;
		}
		cp;
	} else {
		var left = vector_new(4);
		var right = vector_new(4);
		var mid = size / 2;
		var i = 0;
		while (i < mid) {
			vector_push(left, vector_get(pt, i));
			i = i + 1;
		}
		while (i < size) {
			vector_push(right, vector_get(pt, i));
			i = i + 1;
		}
		var left_sorted = mergesort(left);
		vector_delete(left);
		var right_sorted = mergesort(right);
		vector_delete(right);
		var sorted = vector_new(4);
		i = 0;
		var j = 0;
		while (i < vector_size(left_sorted) && j < vector_size(right_sorted)) {
			var a = vector_get(left_sorted, i);
			var b = vector_get(right_sorted, j);
			if (b > a) {
				vector_push(sorted, a);
				i = i + 1;
			} else {
				vector_push(sorted, b);
				j = j + 1;
			}
		}
		while (i < vector_size(left_sorted)) {
			vector_push(sorted, vector_get(left_sorted, i));
			i = i + 1;
		}
		while (j < vector_size(right_sorted)) {
			vector_push(sorted, vector_get(right_sorted, j));
			j = j + 1;
		}
		vector_delete(left_sorted);
		vector_delete(right_sorted);
		sorted;
	}
}

def io_printstring(var vec) {
	var i = 0;
	while (i < vector_size(vec)) {
		io_putchar(vector_get(vec, i));
		i = i + 1;
	}
	vec;
}

def rand() {
	asm {
		#rand r13;
	};
}

def abs(var x) {
	if (x < 0) {
		-x;
	} else {
		x;
	}
}