diff --git a/py/.gitignore b/py/.gitignore
new file mode 100644
index 0000000..5761abc
--- /dev/null
+++ b/py/.gitignore
@@ -0,0 +1 @@
+*.o
diff --git a/py/Makefile b/py/Makefile
new file mode 100644
index 0000000..669453d
--- /dev/null
+++ b/py/Makefile
@@ -0,0 +1,50 @@
+CC = gcc
+CFLAGS = -Wall -ansi -std=gnu99 -Os #-DNDEBUG
+LDFLAGS =
+
+SRC = \
+	malloc.c \
+	misc.c \
+	qstr.c \
+	lexer.c \
+	lexerfile.c \
+	parse.c \
+	scope.c \
+	compile.c \
+	emitcommon.c \
+	emitcpy.c \
+	emitbc.c \
+	asmx64.c \
+	emitx64v2.c \
+	emitthumb.c \
+	asmthumb.c \
+	runtime.c \
+	bc.c \
+	main.c \
+
+SRC_ASM = \
+	runtime1.s \
+
+OBJ = $(SRC:.c=.o) $(SRC_ASM:.s=.o)
+LIB =
+PROG = py
+
+$(PROG): $(OBJ)
+	$(CC) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
+
+runtime.o: runtime.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+bc.o: bc.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+parse.o: grammar.h
+compile.o: grammar.h
+emitcpy.o: emit.h
+emitbc.o: emit.h
+emitx64.o: emit.h
+emitx64v2.o: emit.h
+emitthumb.o: emit.h
+
+clean:
+	/bin/rm $(OBJ)
diff --git a/py/asmthumb.c b/py/asmthumb.c
new file mode 100644
index 0000000..ea7547d
--- /dev/null
+++ b/py/asmthumb.c
@@ -0,0 +1,421 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "asmthumb.h"
+
+#define UNSIGNED_FIT8(x) (((x) & 0xffffff00) == 0)
+#define UNSIGNED_FIT16(x) (((x) & 0xffff0000) == 0)
+#define SIGNED_FIT8(x) (((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80)
+#define SIGNED_FIT9(x) (((x) & 0xffffff00) == 0) || (((x) & 0xffffff00) == 0xffffff00)
+#define SIGNED_FIT12(x) (((x) & 0xfffff800) == 0) || (((x) & 0xfffff800) == 0xfffff800)
+
+struct _asm_thumb_t {
+    int pass;
+    uint code_offset;
+    uint code_size;
+    byte *code_base;
+    byte dummy_data[8];
+
+    int next_label;
+    int max_num_labels;
+    int *label_offsets;
+    int num_locals;
+    uint push_reglist;
+    uint stack_adjust;
+};
+
+asm_thumb_t *asm_thumb_new() {
+    asm_thumb_t *as;
+
+    as = m_new(asm_thumb_t, 1);
+    as->pass = 0;
+    as->code_offset = 0;
+    as->code_size = 0;
+    as->code_base = NULL;
+    as->label_offsets = NULL;
+    as->num_locals = 0;
+
+    return as;
+}
+
+void asm_thumb_free(asm_thumb_t *as, bool free_code) {
+    if (free_code) {
+        m_free(as->code_base);
+    }
+    /*
+    if (as->label != NULL) {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+        {
+            Label *lab = &g_array_index(as->label, Label, i);
+            if (lab->unresolved != NULL)
+                g_array_free(lab->unresolved, true);
+        }
+        g_array_free(as->label, true);
+    }
+    */
+    m_free(as);
+}
+
+void asm_thumb_start_pass(asm_thumb_t *as, int pass) {
+    as->pass = pass;
+    as->code_offset = 0;
+    as->next_label = 1;
+    if (pass == ASM_THUMB_PASS_1) {
+        as->max_num_labels = 0;
+    } else {
+        if (pass == ASM_THUMB_PASS_2) {
+            memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
+        }
+    }
+}
+
+void asm_thumb_end_pass(asm_thumb_t *as) {
+    if (as->pass == ASM_THUMB_PASS_1) {
+        // calculate number of labels need
+        if (as->next_label > as->max_num_labels) {
+            as->max_num_labels = as->next_label;
+        }
+        as->label_offsets = m_new(int, as->max_num_labels);
+    } else if (as->pass == ASM_THUMB_PASS_2) {
+        // calculate size of code in bytes
+        as->code_size = as->code_offset;
+        as->code_base = m_new(byte, as->code_size);
+        printf("code_size: %u\n", as->code_size);
+    }
+
+    /*
+    // check labels are resolved
+    if (as->label != NULL)
+    {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+            if (g_array_index(as->label, Label, i).unresolved != NULL)
+                return false;
+    }
+    */
+}
+
+// all functions must go through this one to emit bytes
+static byte *asm_thumb_get_cur_to_write_bytes(asm_thumb_t *as, int num_bytes_to_write) {
+    //printf("emit %d\n", num_bytes_to_write);
+    if (as->pass < ASM_THUMB_PASS_3) {
+        as->code_offset += num_bytes_to_write;
+        return as->dummy_data;
+    } else {
+        assert(as->code_offset + num_bytes_to_write <= as->code_size);
+        byte *c = as->code_base + as->code_offset;
+        as->code_offset += num_bytes_to_write;
+        return c;
+    }
+}
+
+uint asm_thumb_get_code_size(asm_thumb_t *as) {
+    return as->code_size;
+}
+
+void *asm_thumb_get_code(asm_thumb_t *as) {
+    // need to set low bit to indicate that it's thumb code
+    return (void *)(((machine_uint_t)as->code_base) | 1);
+}
+
+/*
+static void asm_thumb_write_byte_1(asm_thumb_t *as, byte b1) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 1);
+    c[0] = b1;
+}
+*/
+
+static void asm_thumb_write_op16(asm_thumb_t *as, uint op) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 2);
+    // little endian
+    c[0] = op;
+    c[1] = op >> 8;
+}
+
+static void asm_thumb_write_op32(asm_thumb_t *as, uint op1, uint op2) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 4);
+    // little endian, op1 then op2
+    c[0] = op1;
+    c[1] = op1 >> 8;
+    c[2] = op2;
+    c[3] = op2 >> 8;
+}
+
+/*
+#define IMM32_L0(x) ((x) & 0xff)
+#define IMM32_L1(x) (((x) >> 8) & 0xff)
+#define IMM32_L2(x) (((x) >> 16) & 0xff)
+#define IMM32_L3(x) (((x) >> 24) & 0xff)
+
+static void asm_thumb_write_word32(asm_thumb_t *as, int w32) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 4);
+    c[0] = IMM32_L0(w32);
+    c[1] = IMM32_L1(w32);
+    c[2] = IMM32_L2(w32);
+    c[3] = IMM32_L3(w32);
+}
+*/
+
+// rlolist is a bit map indicating desired lo-registers
+#define OP_PUSH_RLIST(rlolist)      (0xb400 | (rlolist))
+#define OP_PUSH_RLIST_LR(rlolist)   (0xb400 | 0x0100 | (rlolist))
+#define OP_POP_RLIST(rlolist)       (0xbc00 | (rlolist))
+#define OP_POP_RLIST_PC(rlolist)    (0xbc00 | 0x0100 | (rlolist))
+
+#define OP_ADD_SP(num_words) (0xb000 | (num_words))
+#define OP_SUB_SP(num_words) (0xb080 | (num_words))
+
+void asm_thumb_entry(asm_thumb_t *as, int num_locals) {
+    // work out what to push and how many extra space to reserve on stack
+    // so that we have enough for all locals and it's aligned an 8-byte boundary
+    uint reglist;
+    uint stack_adjust;
+    if (num_locals < 0) {
+        num_locals = 0;
+    }
+    // don't ppop r0 because it's used for return value
+    switch (num_locals) {
+        case 0:
+            reglist = 0xf2;
+            stack_adjust = 0;
+            break;
+
+        case 1:
+            reglist = 0xf2;
+            stack_adjust = 0;
+            break;
+
+        case 2:
+            reglist = 0xfe;
+            stack_adjust = 0;
+            break;
+
+        case 3:
+            reglist = 0xfe;
+            stack_adjust = 0;
+            break;
+
+        default:
+            reglist = 0xfe;
+            stack_adjust = ((num_locals - 3) + 1) & (~1);
+            break;
+    }
+    asm_thumb_write_op16(as, OP_PUSH_RLIST_LR(reglist));
+    if (stack_adjust > 0) {
+        asm_thumb_write_op16(as, OP_SUB_SP(stack_adjust));
+    }
+    as->push_reglist = reglist;
+    as->stack_adjust = stack_adjust;
+    as->num_locals = num_locals;
+}
+
+void asm_thumb_exit(asm_thumb_t *as) {
+    if (as->stack_adjust > 0) {
+        asm_thumb_write_op16(as, OP_ADD_SP(as->stack_adjust));
+    }
+    asm_thumb_write_op16(as, OP_POP_RLIST_PC(as->push_reglist));
+}
+
+int asm_thumb_label_new(asm_thumb_t *as) {
+    return as->next_label++;
+}
+
+void asm_thumb_label_assign(asm_thumb_t *as, int label) {
+    if (as->pass > ASM_THUMB_PASS_1) {
+        assert(label < as->max_num_labels);
+        if (as->pass == ASM_THUMB_PASS_2) {
+            // assign label offset
+            assert(as->label_offsets[label] == -1);
+            as->label_offsets[label] = as->code_offset;
+        } else if (as->pass == ASM_THUMB_PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            //printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset);
+            assert(as->label_offsets[label] == as->code_offset);
+        }
+    }
+}
+
+// the i8 value will be zero extended into the r32 register!
+void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8) {
+    assert(rlo_dest < REG_R8);
+    // movs rlo_dest, #i8
+    asm_thumb_write_op16(as, 0x2000 | (rlo_dest << 8) | i8);
+}
+
+// if loading lo half, the i16 value will be zero extended into the r32 register!
+void asm_thumb_mov_i16_to_reg(asm_thumb_t *as, int i16, uint reg_dest, bool load_hi_half) {
+    assert(reg_dest < REG_R15);
+    uint op;
+    if (load_hi_half) {
+        // movt reg_dest, #i16
+        op = 0xf2c0;
+    } else {
+        // movw reg_dest, #i16
+        op = 0xf240;
+    }
+    asm_thumb_write_op32(as, op | ((i16 >> 1) & 0x0400) | ((i16 >> 12) & 0xf), ((i16 << 4) & 0x7000) | (reg_dest << 8) | (i16 & 0xff));
+}
+
+void asm_thumb_mov_reg_i32(asm_thumb_t *as, uint reg_dest, machine_uint_t i32) {
+    // movw, movt does it in 8 bytes
+    // ldr [pc, #], dw does it in 6 bytes, but we might not reach to end of code for dw
+
+    asm_thumb_mov_i16_to_reg(as, i32, reg_dest, false);
+    asm_thumb_mov_i16_to_reg(as, i32 >> 16, reg_dest, true);
+}
+
+void asm_thumb_mov_reg_i32_optimised(asm_thumb_t *as, uint reg_dest, int i32) {
+    if (reg_dest < 8 && UNSIGNED_FIT8(i32)) {
+        asm_thumb_mov_reg_i8(as, reg_dest, i32);
+    } else if (UNSIGNED_FIT16(i32)) {
+        asm_thumb_mov_i16_to_reg(as, i32, reg_dest, false);
+    } else {
+        asm_thumb_mov_reg_i32(as, reg_dest, i32);
+    }
+}
+
+void asm_thumb_mov_reg_reg(asm_thumb_t *as, uint reg_dest, uint reg_src) {
+    uint op_lo;
+    if (reg_src < 8) {
+        op_lo = reg_src << 3;
+    } else {
+        op_lo = 0x40 | ((reg_src - 8) << 3);
+    }
+    if (reg_dest < 8) {
+        op_lo |= reg_dest;
+    } else {
+        op_lo |= 0x80 | (reg_dest - 8);
+    }
+    asm_thumb_write_op16(as, 0x4600 | op_lo);
+}
+
+#define OP_STR_TO_SP_OFFSET(rlo_dest, word_offset) (0x9000 | ((rlo_dest) << 8) | ((word_offset) & 0x00ff))
+#define OP_LDR_FROM_SP_OFFSET(rlo_dest, word_offset) (0x9800 | ((rlo_dest) << 8) | ((word_offset) & 0x00ff))
+
+void asm_thumb_mov_local_reg(asm_thumb_t *as, int local_num, uint rlo_src) {
+    assert(rlo_src < REG_R8);
+    int word_offset = as->num_locals - local_num - 1;
+    assert(as->pass < ASM_THUMB_PASS_3 || word_offset >= 0);
+    asm_thumb_write_op16(as, OP_STR_TO_SP_OFFSET(rlo_src, word_offset));
+}
+
+void asm_thumb_mov_reg_local(asm_thumb_t *as, uint rlo_dest, int local_num) {
+    assert(rlo_dest < REG_R8);
+    int word_offset = as->num_locals - local_num - 1;
+    assert(as->pass < ASM_THUMB_PASS_3 || word_offset >= 0);
+    asm_thumb_write_op16(as, OP_LDR_FROM_SP_OFFSET(rlo_dest, word_offset));
+}
+
+void asm_thumb_mov_reg_local_addr(asm_thumb_t *as, uint reg_dest, int local_num) {
+    assert(0);
+    // see format 12, load address
+    asm_thumb_write_op16(as, 0x0000);
+}
+
+#define OP_ADD_REG_REG_REG(rlo_dest, rlo_src_a, rlo_src_b) (0x1800 | ((rlo_src_b) << 6) | ((rlo_src_a) << 3) | (rlo_dest))
+
+void asm_thumb_add_reg_reg_reg(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b) {
+    asm_thumb_write_op16(as, OP_ADD_REG_REG_REG(rlo_dest, rlo_src_a, rlo_src_b));
+}
+
+#define OP_CMP_REG_REG(rlo_a, rlo_b) (0x4280 | ((rlo_b) << 3) | (rlo_a))
+
+void asm_thumb_cmp_reg_reg(asm_thumb_t *as, uint rlo_a, uint rlo_b) {
+    asm_thumb_write_op16(as, OP_CMP_REG_REG(rlo_a, rlo_b));
+}
+
+void asm_thumb_ite_ge(asm_thumb_t *as) {
+    asm_thumb_write_op16(as, 0xbfac);
+}
+
+#define OP_B(byte_offset) (0xe000 | (((byte_offset) >> 1) & 0x07ff))
+// this could be wrong, because it should have a range of +/- 16MiB...
+#define OP_BW_HI(byte_offset) (0xf000 | (((byte_offset) >> 12) & 0x07ff))
+#define OP_BW_LO(byte_offset) (0xb800 | (((byte_offset) >> 1) & 0x07ff))
+
+void asm_thumb_b_label(asm_thumb_t *as, int label) {
+    if (as->pass > ASM_THUMB_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
+        if (dest >= 0 && rel <= -4) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 12 bit relative jump
+            if (SIGNED_FIT12(rel)) {
+                asm_thumb_write_op16(as, OP_B(rel));
+            } else {
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            asm_thumb_write_op32(as, OP_BW_HI(rel), OP_BW_LO(rel));
+        }
+    }
+}
+
+#define OP_CMP_REG_IMM(rlo, i8) (0x2800 | ((rlo) << 8) | (i8))
+// all these bit arithmetics need coverage testing!
+#define OP_BEQ(byte_offset) (0xd000 | (((byte_offset) >> 1) & 0x00ff))
+#define OP_BEQW_HI(byte_offset) (0xf000 | (((byte_offset) >> 10) & 0x0400) | (((byte_offset) >> 14) & 0x003f))
+#define OP_BEQW_LO(byte_offset) (0x8000 | ((byte_offset) & 0x2000) | (((byte_offset) >> 1) & 0x0fff))
+
+void asm_thumb_cmp_reg_bz_label(asm_thumb_t *as, uint rlo, int label) {
+    assert(rlo < REG_R8);
+
+    // compare reg with 0
+    asm_thumb_write_op16(as, OP_CMP_REG_IMM(rlo, 0));
+
+    // branch if equal
+    if (as->pass > ASM_THUMB_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
+        if (dest >= 0 && rel <= -4) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 12 bit relative jump
+            if (SIGNED_FIT9(rel)) {
+                asm_thumb_write_op16(as, OP_BEQ(rel));
+            } else {
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            asm_thumb_write_op32(as, OP_BEQW_HI(rel), OP_BEQW_LO(rel));
+        }
+    }
+}
+
+#define OP_BLX(reg) (0x4780 | ((reg) << 3))
+#define OP_SVC(arg) (0xdf00 | (arg))
+#define OP_LDR_FROM_BASE_OFFSET(rlo_dest, rlo_base, word_offset) (0x6800 | (((word_offset) << 6) & 0x07c0) | ((rlo_base) << 3) | (rlo_dest))
+
+void asm_thumb_bl_ind(asm_thumb_t *as, void *fun_ptr, uint fun_id, uint reg_temp) {
+    /* TODO make this use less bytes
+    uint rlo_base = REG_R3;
+    uint rlo_dest = REG_R7;
+    uint word_offset = 4;
+    asm_thumb_write_op16(as, 0x0000);
+    asm_thumb_write_op16(as, 0x6800 | (word_offset << 6) | (rlo_base << 3) | rlo_dest); // ldr rlo_dest, [rlo_base, #offset]
+    asm_thumb_write_op16(as, 0x4780 | (REG_R9 << 3)); // blx reg
+    */
+
+    if (0) {
+        // load ptr to function into register using immediate, then branch
+        // not relocatable
+        asm_thumb_mov_reg_i32(as, reg_temp, (machine_uint_t)fun_ptr);
+        asm_thumb_write_op16(as, OP_BLX(reg_temp));
+    } else if (1) {
+        asm_thumb_write_op16(as, OP_LDR_FROM_BASE_OFFSET(reg_temp, REG_R7, fun_id));
+        asm_thumb_write_op16(as, OP_BLX(reg_temp));
+    } else {
+        // use SVC
+        asm_thumb_write_op16(as, OP_SVC(fun_id));
+    }
+}
diff --git a/py/asmthumb.h b/py/asmthumb.h
new file mode 100644
index 0000000..d3ffb9a
--- /dev/null
+++ b/py/asmthumb.h
@@ -0,0 +1,60 @@
+#define ASM_THUMB_PASS_1 (1)
+#define ASM_THUMB_PASS_2 (2)
+#define ASM_THUMB_PASS_3 (3)
+
+#define REG_R0  (0)
+#define REG_R1  (1)
+#define REG_R2  (2)
+#define REG_R3  (3)
+#define REG_R4  (4)
+#define REG_R5  (5)
+#define REG_R6  (6)
+#define REG_R7  (7)
+#define REG_R8  (8)
+#define REG_R9  (9)
+#define REG_R10 (10)
+#define REG_R11 (11)
+#define REG_R12 (12)
+#define REG_R13 (13)
+#define REG_R14 (14)
+#define REG_R15 (15)
+#define REG_LR  (REG_R14)
+
+#define REG_RET REG_R0
+#define REG_ARG_1 REG_R0
+#define REG_ARG_2 REG_R1
+#define REG_ARG_3 REG_R2
+#define REG_ARG_4 REG_R3
+
+typedef struct _asm_thumb_t asm_thumb_t;
+
+asm_thumb_t *asm_thumb_new();
+void asm_thumb_free(asm_thumb_t *as, bool free_code);
+void asm_thumb_start_pass(asm_thumb_t *as, int pass);
+void asm_thumb_end_pass(asm_thumb_t *as);
+uint asm_thumb_get_code_size(asm_thumb_t *as);
+void *asm_thumb_get_code(asm_thumb_t *as);
+
+void asm_thumb_entry(asm_thumb_t *as, int num_locals);
+void asm_thumb_exit(asm_thumb_t *as);
+
+int asm_thumb_label_new(asm_thumb_t *as);
+void asm_thumb_label_assign(asm_thumb_t *as, int label);
+
+// argument order follows ARM, in general dest is first
+
+void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8_src);
+void asm_thumb_mov_reg_i32(asm_thumb_t *as, uint reg_dest, machine_uint_t i32_src);
+void asm_thumb_mov_reg_i32_optimised(asm_thumb_t *as, uint reg_dest, int i32_src);
+void asm_thumb_mov_reg_reg(asm_thumb_t *as, uint reg_dest, uint reg_src);
+void asm_thumb_mov_local_reg(asm_thumb_t *as, int local_num_dest, uint rlo_src);
+void asm_thumb_mov_reg_local(asm_thumb_t *as, uint rlo_dest, int local_num);
+void asm_thumb_mov_reg_local_addr(asm_thumb_t *as, uint reg_dest, int local_num);
+
+void asm_thumb_add_reg_reg_reg(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b);
+void asm_thumb_cmp_reg_reg(asm_thumb_t *as, uint rlo_a, uint rlo_b);
+void asm_thumb_ite_ge(asm_thumb_t *as);
+
+void asm_thumb_b_label(asm_thumb_t *as, int label);
+void asm_thumb_cmp_reg_bz_label(asm_thumb_t *as, uint rlo, int label);
+void asm_thumb_bl_ind(asm_thumb_t *as, void *fun_ptr, uint fun_id, uint reg_temp);
diff --git a/py/asmx64.c b/py/asmx64.c
new file mode 100644
index 0000000..59c8113
--- /dev/null
+++ b/py/asmx64.c
@@ -0,0 +1,621 @@
+#include <stdio.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <string.h>
+
+#include "misc.h"
+#include "asmx64.h"
+
+/* all offsets are measured in multiples of 8 bytes */
+#define WORD_SIZE                (8)
+
+#define OPCODE_NOP               (0x90)
+#define OPCODE_PUSH_R64          (0x50)
+#define OPCODE_PUSH_I64          (0x68)
+#define OPCODE_PUSH_M64          (0xff) /* /6 */
+#define OPCODE_POP_R64           (0x58)
+#define OPCODE_RET               (0xc3)
+#define OPCODE_MOV_I8_TO_R8      (0xb0) /* +rb */
+#define OPCODE_MOV_I64_TO_R64    (0xb8)
+#define OPCODE_MOV_I32_TO_RM32   (0xc7)
+#define OPCODE_MOV_R64_TO_RM64   (0x89)
+#define OPCODE_MOV_RM64_TO_R64   (0x8b)
+#define OPCODE_LEA_MEM_TO_R64    (0x8d) /* /r */
+#define OPCODE_XOR_R64_TO_RM64   (0x31) /* /r */
+#define OPCODE_ADD_R64_TO_RM64   (0x01)
+#define OPCODE_ADD_I32_TO_RM32   (0x81) /* /0 */
+#define OPCODE_ADD_I8_TO_RM32    (0x83) /* /0 */
+#define OPCODE_SUB_R64_FROM_RM64 (0x29)
+#define OPCODE_SUB_I32_FROM_RM64 (0x81) /* /5 */
+#define OPCODE_SUB_I8_FROM_RM64  (0x83) /* /5 */
+#define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
+#define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
+#define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
+#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
+#define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
+#define OPCODE_CMP_R64_WITH_RM64 (0x39)
+#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
+#define OPCODE_TEST_R8_WITH_RM8  (0x84) /* /r */
+#define OPCODE_JMP_REL8          (0xeb)
+#define OPCODE_JMP_REL32         (0xe9)
+#define OPCODE_JCC_REL8          (0x70) /* | jcc type */
+#define OPCODE_JCC_REL32_A       (0x0f)
+#define OPCODE_JCC_REL32_B       (0x80) /* | jcc type */
+#define OPCODE_SETCC_RM8_A       (0x0f)
+#define OPCODE_SETCC_RM8_B       (0x90) /* | jcc type, /0 */
+#define OPCODE_CALL_REL32        (0xe8)
+#define OPCODE_CALL_RM32         (0xff) /* /2 */
+#define OPCODE_LEAVE             (0xc9)
+
+#define MODRM_R64(x)    ((x) << 3)
+#define MODRM_RM_DISP0  (0x00)
+#define MODRM_RM_DISP8  (0x40)
+#define MODRM_RM_DISP32 (0x80)
+#define MODRM_RM_REG    (0xc0)
+#define MODRM_RM_R64(x) (x)
+
+#define REX_PREFIX  (0x40)
+#define REX_W       (0x08)  // width
+#define REX_R       (0x04)  // register
+#define REX_X       (0x02)  // index
+#define REX_B       (0x01)  // base
+
+#define IMM32_L0(x) ((x) & 0xff)
+#define IMM32_L1(x) (((x) >> 8) & 0xff)
+#define IMM32_L2(x) (((x) >> 16) & 0xff)
+#define IMM32_L3(x) (((x) >> 24) & 0xff)
+#define IMM64_L4(x) (((x) >> 32) & 0xff)
+#define IMM64_L5(x) (((x) >> 40) & 0xff)
+#define IMM64_L6(x) (((x) >> 48) & 0xff)
+#define IMM64_L7(x) (((x) >> 56) & 0xff)
+
+#define UNSIGNED_FIT8(x) (((x) & 0xffffffffffffff00) == 0)
+#define UNSIGNED_FIT32(x) (((x) & 0xffffffff00000000) == 0)
+#define SIGNED_FIT8(x) (((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80)
+
+struct _asm_x64_t {
+    int pass;
+    uint code_offset;
+    uint code_size;
+    byte *code_base;
+    byte dummy_data[8];
+
+    int next_label;
+    int max_num_labels;
+    int *label_offsets;
+};
+
+// for allocating memory, see src/v8/src/platform-linux.cc
+void *alloc_mem(uint req_size, uint *alloc_size, bool is_exec) {
+    req_size = (req_size + 0xfff) & (~0xfff);
+    int prot = PROT_READ | PROT_WRITE | (is_exec ? PROT_EXEC : 0);
+    void *ptr = mmap(NULL, req_size, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (ptr == MAP_FAILED) {
+        assert(0);
+    }
+    *alloc_size = req_size;
+    return ptr;
+}
+
+asm_x64_t* asm_x64_new() {
+    asm_x64_t* as;
+
+    as = m_new(asm_x64_t, 1);
+    as->pass = 0;
+    as->code_offset = 0;
+    as->code_size = 0;
+    as->code_base = NULL;
+    as->label_offsets = NULL;
+
+    return as;
+}
+
+void asm_x64_free(asm_x64_t* as, bool free_code) {
+    if (free_code) {
+        m_free(as->code_base);
+    }
+    /*
+    if (as->label != NULL) {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+        {
+            Label* lab = &g_array_index(as->label, Label, i);
+            if (lab->unresolved != NULL)
+                g_array_free(lab->unresolved, true);
+        }
+        g_array_free(as->label, true);
+    }
+    */
+    m_free(as);
+}
+
+void asm_x64_start_pass(asm_x64_t *as, int pass) {
+    as->pass = pass;
+    as->code_offset = 0;
+    as->next_label = 1;
+    if (pass == ASM_X64_PASS_1) {
+        as->max_num_labels = 0;
+    } else {
+        if (pass == ASM_X64_PASS_2) {
+            memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
+        }
+    }
+}
+
+void asm_x64_end_pass(asm_x64_t *as) {
+    if (as->pass == ASM_X64_PASS_1) {
+        // calculate number of labels need
+        if (as->next_label > as->max_num_labels) {
+            as->max_num_labels = as->next_label;
+        }
+        as->label_offsets = m_new(int, as->max_num_labels);
+    } else if (as->pass == ASM_X64_PASS_2) {
+        // calculate size of code in bytes
+        as->code_size = as->code_offset;
+        as->code_base = m_new(byte, as->code_size);
+        printf("code_size: %u\n", as->code_size);
+    }
+
+    /*
+    // check labels are resolved
+    if (as->label != NULL)
+    {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+            if (g_array_index(as->label, Label, i).unresolved != NULL)
+                return false;
+    }
+    */
+}
+
+// all functions must go through this one to emit bytes
+static byte* asm_x64_get_cur_to_write_bytes(asm_x64_t* as, int num_bytes_to_write) {
+    //printf("emit %d\n", num_bytes_to_write);
+    if (as->pass < ASM_X64_PASS_3) {
+        as->code_offset += num_bytes_to_write;
+        return as->dummy_data;
+    } else {
+        assert(as->code_offset + num_bytes_to_write <= as->code_size);
+        byte *c = as->code_base + as->code_offset;
+        as->code_offset += num_bytes_to_write;
+        return c;
+    }
+}
+
+uint asm_x64_get_code_size(asm_x64_t* as) {
+    return as->code_size;
+}
+
+void* asm_x64_get_code(asm_x64_t* as) {
+    return as->code_base;
+}
+
+static void asm_x64_write_byte_1(asm_x64_t* as, byte b1) {
+    byte* c = asm_x64_get_cur_to_write_bytes(as, 1);
+    c[0] = b1;
+}
+
+static void asm_x64_write_byte_2(asm_x64_t* as, byte b1, byte b2) {
+    byte* c = asm_x64_get_cur_to_write_bytes(as, 2);
+    c[0] = b1;
+    c[1] = b2;
+}
+
+static void asm_x64_write_byte_3(asm_x64_t* as, byte b1, byte b2, byte b3) {
+    byte* c = asm_x64_get_cur_to_write_bytes(as, 3);
+    c[0] = b1;
+    c[1] = b2;
+    c[2] = b3;
+}
+
+static void asm_x64_write_word32(asm_x64_t* as, int w32) {
+    byte* c = asm_x64_get_cur_to_write_bytes(as, 4);
+    c[0] = IMM32_L0(w32);
+    c[1] = IMM32_L1(w32);
+    c[2] = IMM32_L2(w32);
+    c[3] = IMM32_L3(w32);
+}
+
+static void asm_x64_write_word64(asm_x64_t* as, int64_t w64) {
+    byte* c = asm_x64_get_cur_to_write_bytes(as, 8);
+    c[0] = IMM32_L0(w64);
+    c[1] = IMM32_L1(w64);
+    c[2] = IMM32_L2(w64);
+    c[3] = IMM32_L3(w64);
+    c[4] = IMM64_L4(w64);
+    c[5] = IMM64_L5(w64);
+    c[6] = IMM64_L6(w64);
+    c[7] = IMM64_L7(w64);
+}
+
+/* unused
+static void asm_x64_write_word32_to(asm_x64_t* as, int offset, int w32) {
+    byte* c;
+    assert(offset + 4 <= as->code_size);
+    c = as->code_base + offset;
+    c[0] = IMM32_L0(w32);
+    c[1] = IMM32_L1(w32);
+    c[2] = IMM32_L2(w32);
+    c[3] = IMM32_L3(w32);
+}
+*/
+
+static void asm_x64_write_r64_disp(asm_x64_t* as, int r64, int disp_r64, int disp_offset) {
+    assert(disp_r64 != REG_RSP);
+
+    if (disp_offset == 0 && disp_r64 != REG_RBP) {
+        asm_x64_write_byte_1(as, MODRM_R64(r64) | MODRM_RM_DISP0 | MODRM_RM_R64(disp_r64));
+    } else if (SIGNED_FIT8(disp_offset)) {
+        asm_x64_write_byte_2(as, MODRM_R64(r64) | MODRM_RM_DISP8 | MODRM_RM_R64(disp_r64), IMM32_L0(disp_offset));
+    } else {
+        asm_x64_write_byte_1(as, MODRM_R64(r64) | MODRM_RM_DISP32 | MODRM_RM_R64(disp_r64));
+        asm_x64_write_word32(as, disp_offset);
+    }
+}
+
+void asm_x64_nop(asm_x64_t* as)
+{
+    asm_x64_write_byte_1(as, OPCODE_NOP);
+}
+
+void asm_x64_push_r64(asm_x64_t* as, int src_r64)
+{
+    asm_x64_write_byte_1(as, OPCODE_PUSH_R64 | src_r64);
+}
+
+void asm_x64_push_i32(asm_x64_t* as, int src_i32)
+{
+    asm_x64_write_byte_1(as, OPCODE_PUSH_I64);
+    asm_x64_write_word32(as, src_i32); // will be sign extended to 64 bits
+}
+
+void asm_x64_push_disp(asm_x64_t* as, int src_r64, int src_offset) {
+    asm_x64_write_byte_1(as, OPCODE_PUSH_M64);
+    asm_x64_write_r64_disp(as, 6, src_r64, src_offset);
+}
+
+void asm_x64_pop_r64(asm_x64_t* as, int dest_r64)
+{
+    asm_x64_write_byte_1(as, OPCODE_POP_R64 | dest_r64);
+}
+
+static void asm_x64_ret(asm_x64_t* as)
+{
+    asm_x64_write_byte_1(as, OPCODE_RET);
+}
+
+void asm_x64_mov_r32_to_r32(asm_x64_t* as, int src_r32, int dest_r32) {
+    // defaults to 32 bit operation
+    asm_x64_write_byte_2(as, OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+}
+
+void asm_x64_mov_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64) {
+    // use REX prefix for 64 bit operation
+    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+}
+
+void asm_x64_mov_r64_to_disp(asm_x64_t* as, int src_r64, int dest_r64, int dest_disp) {
+    // use REX prefix for 64 bit operation
+    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_MOV_R64_TO_RM64);
+    asm_x64_write_r64_disp(as, src_r64, dest_r64, dest_disp);
+}
+
+void asm_x64_mov_disp_to_r64(asm_x64_t* as, int src_r64, int src_disp, int dest_r64) {
+    // use REX prefix for 64 bit operation
+    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_MOV_RM64_TO_R64);
+    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
+}
+
+void asm_x64_lea_disp_to_r64(asm_x64_t* as, int src_r64, int src_disp, int dest_r64) {
+    // use REX prefix for 64 bit operation
+    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_LEA_MEM_TO_R64);
+    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
+}
+
+void asm_x64_mov_i8_to_r8(asm_x64_t *as, int src_i8, int dest_r64) {
+    asm_x64_write_byte_2(as, OPCODE_MOV_I8_TO_R8 | dest_r64, src_i8);
+}
+
+void asm_x64_mov_i32_to_r64(asm_x64_t* as, int src_i32, int dest_r64) {
+    // cpu defaults to i32 to r64, with zero extension
+    asm_x64_write_byte_1(as, OPCODE_MOV_I64_TO_R64 | dest_r64);
+    asm_x64_write_word32(as, src_i32);
+}
+
+void asm_x64_mov_i64_to_r64(asm_x64_t* as, int64_t src_i64, int dest_r64) {
+    // cpu defaults to i32 to r64
+    // to mov i64 to r64 need to use REX prefix
+    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_MOV_I64_TO_R64 | dest_r64);
+    asm_x64_write_word64(as, src_i64);
+}
+
+void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64) {
+    if (UNSIGNED_FIT32(src_i64)) {
+        // 5 bytes
+        asm_x64_mov_i32_to_r64(as, src_i64 & 0xffffffff, dest_r64);
+    } else {
+        // 10 bytes
+        asm_x64_mov_i64_to_r64(as, src_i64, dest_r64);
+    }
+}
+
+void asm_x64_mov_i32_to_disp(asm_x64_t* as, int src_i32, int dest_r32, int dest_disp)
+{
+    assert(0);
+    asm_x64_write_byte_1(as, OPCODE_MOV_I32_TO_RM32);
+    //asm_x64_write_r32_disp(as, 0, dest_r32, dest_disp);
+    asm_x64_write_word32(as, src_i32);
+}
+
+void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
+    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_XOR_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+}
+
+void asm_x64_add_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64) {
+    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_ADD_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+}
+
+void asm_x64_add_i32_to_r32(asm_x64_t* as, int src_i32, int dest_r32)
+{
+    assert(dest_r32 != REG_RSP); // in this case i think src_i32 must be 64 bits
+    if (SIGNED_FIT8(src_i32))
+    {
+        asm_x64_write_byte_2(as, OPCODE_ADD_I8_TO_RM32, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+        asm_x64_write_byte_1(as, src_i32 & 0xff);
+    }
+    else
+    {
+        asm_x64_write_byte_2(as, OPCODE_ADD_I32_TO_RM32, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+        asm_x64_write_word32(as, src_i32);
+    }
+}
+
+void asm_x64_sub_r32_from_r32(asm_x64_t* as, int src_r32, int dest_r32) {
+    // defaults to 32 bit operation
+    asm_x64_write_byte_2(as, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+}
+
+void asm_x64_sub_r64_from_r64(asm_x64_t* as, int src_r64, int dest_r64) {
+    // use REX prefix for 64 bit operation
+    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+}
+
+void asm_x64_sub_i32_from_r32(asm_x64_t* as, int src_i32, int dest_r32) {
+    if (SIGNED_FIT8(src_i32)) {
+        // defaults to 32 bit operation
+        asm_x64_write_byte_2(as, OPCODE_SUB_I8_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+        asm_x64_write_byte_1(as, src_i32 & 0xff);
+    } else {
+        // defaults to 32 bit operation
+        asm_x64_write_byte_2(as, OPCODE_SUB_I32_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+        asm_x64_write_word32(as, src_i32);
+    }
+}
+
+void asm_x64_sub_i32_from_r64(asm_x64_t* as, int src_i32, int dest_r64) {
+    if (SIGNED_FIT8(src_i32)) {
+        // use REX prefix for 64 bit operation
+        asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_I8_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+        asm_x64_write_byte_1(as, src_i32 & 0xff);
+    } else {
+        // use REX prefix for 64 bit operation
+        asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_I32_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+        asm_x64_write_word32(as, src_i32);
+    }
+}
+
+/* shifts not tested */
+void asm_x64_shl_r32_by_imm(asm_x64_t* as, int r32, int imm) {
+    asm_x64_write_byte_2(as, OPCODE_SHL_RM32_BY_I8, MODRM_R64(4) | MODRM_RM_REG | MODRM_RM_R64(r32));
+    asm_x64_write_byte_1(as, imm);
+}
+
+void asm_x64_shr_r32_by_imm(asm_x64_t* as, int r32, int imm) {
+    asm_x64_write_byte_2(as, OPCODE_SHR_RM32_BY_I8, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(r32));
+    asm_x64_write_byte_1(as, imm);
+}
+
+void asm_x64_sar_r32_by_imm(asm_x64_t* as, int r32, int imm) {
+    asm_x64_write_byte_2(as, OPCODE_SAR_RM32_BY_I8, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(r32));
+    asm_x64_write_byte_1(as, imm);
+}
+
+void asm_x64_cmp_r64_with_r64(asm_x64_t* as, int src_r64_a, int src_r64_b) {
+    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_CMP_R64_WITH_RM64, MODRM_R64(src_r64_a) | MODRM_RM_REG | MODRM_RM_R64(src_r64_b));
+}
+
+void asm_x64_cmp_r32_with_disp(asm_x64_t* as, int src_r32_a, int src_r32_b, int src_disp_b) {
+    assert(0);
+    asm_x64_write_byte_1(as, OPCODE_CMP_R64_WITH_RM64);
+    //asm_x64_write_r32_disp(as, src_r32_a, src_r32_b, src_disp_b);
+}
+
+void asm_x64_cmp_disp_with_r32(asm_x64_t* as, int src_r32_a, int src_disp_a, int src_r32_b) {
+    assert(0);
+    asm_x64_write_byte_1(as, OPCODE_CMP_RM32_WITH_R32);
+    //asm_x64_write_r32_disp(as, src_r32_b, src_r32_a, src_disp_a);
+}
+
+void asm_x64_cmp_i32_with_r32(asm_x64_t* as, int src_i32, int src_r32) {
+    if (SIGNED_FIT8(src_i32)) {
+        asm_x64_write_byte_2(as, OPCODE_CMP_I8_WITH_RM32, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(src_r32));
+        asm_x64_write_byte_1(as, src_i32 & 0xff);
+    } else {
+        asm_x64_write_byte_2(as, OPCODE_CMP_I32_WITH_RM32, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(src_r32));
+        asm_x64_write_word32(as, src_i32);
+    }
+}
+
+void asm_x64_test_r8_with_r8(asm_x64_t* as, int src_r64_a, int src_r64_b) {
+    asm_x64_write_byte_2(as, OPCODE_TEST_R8_WITH_RM8, MODRM_R64(src_r64_a) | MODRM_RM_REG | MODRM_RM_R64(src_r64_b));
+}
+
+void asm_x64_setcc_r8(asm_x64_t* as, int jcc_type, int dest_r8) {
+    asm_x64_write_byte_3(as, OPCODE_SETCC_RM8_A, OPCODE_SETCC_RM8_B | jcc_type, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r8));
+}
+
+int asm_x64_label_new(asm_x64_t* as) {
+    return as->next_label++;
+}
+
+void asm_x64_label_assign(asm_x64_t* as, int label) {
+    if (as->pass > ASM_X64_PASS_1) {
+        assert(label < as->max_num_labels);
+        if (as->pass == ASM_X64_PASS_2) {
+            // assign label offset
+            assert(as->label_offsets[label] == -1);
+            as->label_offsets[label] = as->code_offset;
+        } else if (as->pass == ASM_X64_PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            //printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset);
+            assert(as->label_offsets[label] == as->code_offset);
+        }
+    }
+}
+
+void asm_x64_jmp_label(asm_x64_t* as, int label) {
+    if (as->pass > ASM_X64_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        if (dest >= 0 && rel < 0) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 8 bit relative jump
+            rel -= 2;
+            if (SIGNED_FIT8(rel)) {
+                asm_x64_write_byte_2(as, OPCODE_JMP_REL8, rel & 0xff);
+            } else {
+                rel += 2;
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            rel -= 5;
+            asm_x64_write_byte_1(as, OPCODE_JMP_REL32);
+            asm_x64_write_word32(as, rel);
+        }
+    }
+}
+
+void asm_x64_jcc_label(asm_x64_t* as, int jcc_type, int label) {
+    if (as->pass > ASM_X64_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        if (dest >= 0 && rel < 0) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 8 bit relative jump
+            rel -= 2;
+            if (SIGNED_FIT8(rel)) {
+                asm_x64_write_byte_2(as, OPCODE_JCC_REL8 | jcc_type, rel & 0xff);
+            } else {
+                rel += 2;
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            rel -= 6;
+            asm_x64_write_byte_2(as, OPCODE_JCC_REL32_A, OPCODE_JCC_REL32_B | jcc_type);
+            asm_x64_write_word32(as, rel);
+        }
+    }
+}
+
+void asm_x64_entry(asm_x64_t* as, int num_locals) {
+    asm_x64_push_r64(as, REG_RBP);
+    asm_x64_mov_r64_to_r64(as, REG_RSP, REG_RBP);
+    if (num_locals < 0) {
+        num_locals = 0;
+    }
+    num_locals |= 1; // make it odd so stack is aligned on 16 byte boundary
+    asm_x64_sub_i32_from_r64(as, num_locals * WORD_SIZE, REG_RSP);
+    asm_x64_push_r64(as, REG_RBX);
+}
+
+void asm_x64_exit(asm_x64_t* as) {
+    asm_x64_pop_r64(as, REG_RBX);
+    asm_x64_write_byte_1(as, OPCODE_LEAVE);
+    asm_x64_ret(as);
+}
+
+void asm_x64_push_arg(asm_x64_t* as, int src_arg_num) {
+    assert(0);
+    asm_x64_push_disp(as, REG_RBP, 8 + src_arg_num * WORD_SIZE);
+}
+
+void asm_x64_mov_arg_to_r32(asm_x64_t* as, int src_arg_num, int dest_r32) {
+    assert(0);
+    //asm_x64_mov_disp_to_r32(as, REG_RBP, 8 + src_arg_num * WORD_SIZE, dest_r32);
+}
+
+void asm_x64_mov_r32_to_arg(asm_x64_t* as, int src_r32, int dest_arg_num) {
+    assert(0);
+    //asm_x64_mov_r32_to_disp(as, src_r32, REG_RBP, 8 + dest_arg_num * WORD_SIZE);
+}
+
+static int asm_x64_local_offset_from_ebp(int local_num)
+{
+    return -(local_num + 1) * WORD_SIZE;
+}
+
+void asm_x64_mov_local_to_r64(asm_x64_t* as, int src_local_num, int dest_r64) {
+    asm_x64_mov_disp_to_r64(as, REG_RBP, asm_x64_local_offset_from_ebp(src_local_num), dest_r64);
+}
+
+void asm_x64_mov_r64_to_local(asm_x64_t* as, int src_r64, int dest_local_num) {
+    asm_x64_mov_r64_to_disp(as, src_r64, REG_RBP, asm_x64_local_offset_from_ebp(dest_local_num));
+}
+
+void asm_x64_mov_local_addr_to_r64(asm_x64_t* as, int local_num, int dest_r64) {
+    int offset = asm_x64_local_offset_from_ebp(local_num);
+    if (offset == 0) {
+        asm_x64_mov_r64_to_r64(as, REG_RBP, dest_r64);
+    } else {
+        asm_x64_lea_disp_to_r64(as, REG_RBP, offset, dest_r64);
+    }
+}
+
+void asm_x64_push_local(asm_x64_t* as, int local_num) {
+    asm_x64_push_disp(as, REG_RBP, asm_x64_local_offset_from_ebp(local_num));
+}
+
+void asm_x64_push_local_addr(asm_x64_t* as, int local_num, int temp_r64)
+{
+    asm_x64_mov_r64_to_r64(as, REG_RBP, temp_r64);
+    asm_x64_add_i32_to_r32(as, asm_x64_local_offset_from_ebp(local_num), temp_r64);
+    asm_x64_push_r64(as, temp_r64);
+}
+
+/*
+   can't use these because code might be relocated when resized
+
+void asm_x64_call(asm_x64_t* as, void* func)
+{
+    asm_x64_sub_i32_from_r32(as, 8, REG_RSP);
+    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
+    asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
+    asm_x64_mov_r64_to_r64(as, REG_RBP, REG_RSP);
+}
+
+void asm_x64_call_i1(asm_x64_t* as, void* func, int i1)
+{
+    asm_x64_sub_i32_from_r32(as, 8, REG_RSP);
+    asm_x64_sub_i32_from_r32(as, 12, REG_RSP);
+    asm_x64_push_i32(as, i1);
+    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
+    asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
+    asm_x64_add_i32_to_r32(as, 16, REG_RSP);
+    asm_x64_mov_r64_to_r64(as, REG_RBP, REG_RSP);
+}
+*/
+
+void asm_x64_call_ind(asm_x64_t* as, void *ptr, int temp_r64) {
+    /*
+    asm_x64_mov_i64_to_r64_optimised(as, (int64_t)ptr, temp_r64);
+    asm_x64_write_byte_2(as, OPCODE_CALL_RM32, MODRM_R64(2) | MODRM_RM_REG | MODRM_RM_R64(temp_r64));
+    */
+    // this reduces code size by 2 bytes per call, but doesn't seem to speed it up at all
+    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
+    asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
+}
diff --git a/py/asmx64.h b/py/asmx64.h
new file mode 100644
index 0000000..4871dbf
--- /dev/null
+++ b/py/asmx64.h
@@ -0,0 +1,76 @@
+#define ASM_X64_PASS_1 (1)
+#define ASM_X64_PASS_2 (2)
+#define ASM_X64_PASS_3 (3)
+
+#define REG_RAX (0)
+#define REG_RCX (1)
+#define REG_RDX (2)
+#define REG_RBX (3)
+#define REG_RSP (4)
+#define REG_RBP (5)
+#define REG_RSI (6)
+#define REG_RDI (7)
+
+// condition codes, used for jcc and setcc (desipite their j-name!)
+#define JCC_JB  (0x2) // below, unsigned
+#define JCC_JZ  (0x4)
+#define JCC_JE  (0x4)
+#define JCC_JNZ (0x5)
+#define JCC_JNE (0x5)
+#define JCC_JL  (0xc) // less, signed
+
+#define REG_RET REG_RAX
+#define REG_ARG_1 REG_RDI
+#define REG_ARG_2 REG_RSI
+#define REG_ARG_3 REG_RDX
+
+typedef struct _asm_x64_t asm_x64_t;
+
+asm_x64_t* asm_x64_new();
+void asm_x64_free(asm_x64_t* as, bool free_code);
+void asm_x64_start_pass(asm_x64_t *as, int pass);
+void asm_x64_end_pass(asm_x64_t *as);
+uint asm_x64_get_code_size(asm_x64_t* as);
+void* asm_x64_get_code(asm_x64_t* as);
+
+void asm_x64_nop(asm_x64_t* as);
+void asm_x64_push_r64(asm_x64_t* as, int src_r64);
+void asm_x64_push_i32(asm_x64_t* as, int src_i32); // will be sign extended to 64 bits
+void asm_x64_push_disp(asm_x64_t* as, int src_r32, int src_offset);
+void asm_x64_pop_r64(asm_x64_t* as, int dest_r64);
+void asm_x64_mov_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_mov_r32_to_disp(asm_x64_t* as, int src_r32, int dest_r32, int dest_disp);
+void asm_x64_mov_disp_to_r32(asm_x64_t* as, int src_r32, int src_disp, int dest_r32);
+void asm_x64_mov_i32_to_r64(asm_x64_t* as, int src_i32, int dest_r64);
+void asm_x64_mov_i64_to_r64(asm_x64_t* as, int64_t src_i64, int dest_r64);
+void asm_x64_mov_i32_to_disp(asm_x64_t* as, int src_i32, int dest_r32, int dest_disp);
+void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64);
+void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64);
+void asm_x64_add_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_add_i32_to_r32(asm_x64_t* as, int src_i32, int dest_r32);
+void asm_x64_sub_r32_from_r32(asm_x64_t* as, int src_r32, int dest_r32);
+void asm_x64_sub_i32_from_r32(asm_x64_t* as, int src_i32, int dest_r32);
+void asm_x64_shl_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_shr_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_sar_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_cmp_r64_with_r64(asm_x64_t* as, int src_r64_a, int src_r64_b);
+void asm_x64_cmp_r32_with_disp(asm_x64_t* as, int src_r32_a, int src_r32_b, int src_disp_b);
+void asm_x64_cmp_disp_with_r32(asm_x64_t* as, int src_r32_a, int src_disp_a, int src_r32_b);
+void asm_x64_cmp_i32_with_r32(asm_x64_t* as, int src_i32, int src_r32);
+void asm_x64_test_r8_with_r8(asm_x64_t* as, int src_r64_a, int src_r64_b);
+void asm_x64_setcc_r8(asm_x64_t* as, int jcc_type, int dest_r8);
+int asm_x64_label_new(asm_x64_t* as);
+void asm_x64_label_assign(asm_x64_t* as, int label);
+void asm_x64_jmp_label(asm_x64_t* as, int label);
+void asm_x64_jcc_label(asm_x64_t* as, int jcc_type, int label);
+void asm_x64_entry(asm_x64_t* as, int num_locals);
+void asm_x64_exit(asm_x64_t* as);
+void asm_x64_push_arg(asm_x64_t* as, int src_arg_num);
+void asm_x64_mov_arg_to_r32(asm_x64_t* as, int src_arg_num, int dest_r32);
+void asm_x64_mov_r32_to_arg(asm_x64_t* as, int src_r32, int dest_arg_num);
+void asm_x64_mov_local_to_r64(asm_x64_t* as, int src_local_num, int dest_r64);
+void asm_x64_mov_r64_to_local(asm_x64_t* as, int src_r64, int dest_local_num);
+void asm_x64_mov_local_addr_to_r64(asm_x64_t* as, int local_num, int dest_r64);
+void asm_x64_push_local(asm_x64_t* as, int local_num);
+void asm_x64_push_local_addr(asm_x64_t* as, int local_num, int temp_r32);
+void asm_x64_call_ind(asm_x64_t* as, void* ptr, int temp_r32);
diff --git a/py/bc.c b/py/bc.c
new file mode 100644
index 0000000..1edd911
--- /dev/null
+++ b/py/bc.c
@@ -0,0 +1,272 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "runtime.h"
+#include "bc.h"
+
+#define DECODE_UINT do { unum = *ip++; if (unum > 127) { unum = ((unum & 0x3f) << 8) | (*ip++); } } while (0)
+#define DECODE_QSTR do { qstr = *ip++; if (qstr > 127) { qstr = ((qstr & 0x3f) << 8) | (*ip++); } } while (0)
+#define PUSH(val) *--sp = (val)
+#define POP() (*sp++)
+
+py_obj_t py_execute_byte_code(byte *code, uint len, py_obj_t *args, uint n_args) {
+    byte *ip = code;
+    py_obj_t stack[10];
+    py_obj_t *sp = &stack[10]; // stack grows down, sp points to top of stack
+    machine_uint_t unum;
+    machine_int_t snum;
+    qstr qstr;
+    py_obj_t obj1, obj2;
+    py_obj_t fast0 = NULL, fast1 = NULL, fast2 = NULL, fastn[4] = {NULL, NULL, NULL, NULL};
+
+    // init args
+    for (int i = 0; i < n_args; i++) {
+        if (i == 0) {
+            fast0 = args[0];
+        } else if (i == 1) {
+            fast1 = args[1];
+        } else if (i == 2) {
+            fast2 = args[2];
+        } else {
+            assert(i - 3 < 4);
+            fastn[i - 3] = args[i];
+        }
+    }
+
+    // execute byte code
+    for (;;) {
+        int op = *ip++;
+        switch (op) {
+            case PYBC_LOAD_CONST_FALSE:
+                PUSH(py_const_false);
+                break;
+
+            case PYBC_LOAD_CONST_NONE:
+                PUSH(py_const_none);
+                break;
+
+            case PYBC_LOAD_CONST_TRUE:
+                PUSH(py_const_true);
+                break;
+
+            case PYBC_LOAD_CONST_SMALL_INT:
+                snum = ip[0] | (ip[1] << 8);
+                if (snum & 0x8000) {
+                    snum |= ~0xffff;
+                }
+                ip += 2;
+                PUSH((py_obj_t)(snum << 1 | 1));
+                break;
+
+            case PYBC_LOAD_CONST_ID:
+                DECODE_QSTR;
+                PUSH(rt_load_const_str(qstr)); // TODO
+                break;
+
+            case PYBC_LOAD_CONST_STRING:
+                DECODE_QSTR;
+                PUSH(rt_load_const_str(qstr));
+                break;
+
+            case PYBC_LOAD_FAST_0:
+                PUSH(fast0);
+                break;
+
+            case PYBC_LOAD_FAST_1:
+                PUSH(fast1);
+                break;
+
+            case PYBC_LOAD_FAST_2:
+                PUSH(fast2);
+                break;
+
+            case PYBC_LOAD_FAST_N:
+                DECODE_UINT;
+                PUSH(fastn[unum - 3]);
+                break;
+
+            case PYBC_LOAD_NAME:
+                DECODE_QSTR;
+                PUSH(rt_load_name(qstr));
+                break;
+
+            case PYBC_LOAD_GLOBAL:
+                DECODE_QSTR;
+                PUSH(rt_load_global(qstr));
+                break;
+
+            case PYBC_LOAD_ATTR:
+                DECODE_QSTR;
+                *sp = rt_load_attr(*sp, qstr);
+                break;
+
+            case PYBC_LOAD_METHOD:
+                DECODE_QSTR;
+                sp -= 1;
+                rt_load_method(sp[1], qstr, sp);
+                break;
+
+            case PYBC_LOAD_BUILD_CLASS:
+                PUSH(rt_load_build_class());
+                break;
+
+            case PYBC_STORE_FAST_0:
+                fast0 = POP();
+                break;
+
+            case PYBC_STORE_FAST_1:
+                fast1 = POP();
+                break;
+
+            case PYBC_STORE_FAST_2:
+                fast2 = POP();
+                break;
+
+            case PYBC_STORE_FAST_N:
+                DECODE_UINT;
+                fastn[unum - 3] = POP();
+                break;
+
+            case PYBC_STORE_NAME:
+                DECODE_QSTR;
+                rt_store_name(qstr, POP());
+                break;
+
+            case PYBC_STORE_SUBSCR:
+                rt_store_subscr(sp[1], sp[0], sp[2]);
+                sp += 3;
+                break;
+
+            case PYBC_DUP_TOP:
+                obj1 = *sp;
+                PUSH(obj1);
+                break;
+
+            case PYBC_DUP_TOP_TWO:
+                sp -= 2;
+                sp[0] = sp[2];
+                sp[1] = sp[3];
+                break;
+
+            case PYBC_POP_TOP:
+                ++sp;
+                break;
+
+            case PYBC_ROT_THREE:
+                obj1 = sp[0];
+                sp[0] = sp[1];
+                sp[1] = sp[2];
+                sp[2] = obj1;
+                break;
+
+            case PYBC_JUMP:
+                DECODE_UINT;
+                ip = code + unum;
+                break;
+
+            case PYBC_POP_JUMP_IF_FALSE:
+                DECODE_UINT;
+                if (!rt_is_true(POP())) {
+                    ip = code + unum;
+                }
+                break;
+
+            case PYBC_SETUP_LOOP:
+                DECODE_UINT;
+                break;
+
+            case PYBC_POP_BLOCK:
+                break;
+
+            case PYBC_BINARY_OP:
+                unum = *ip++;
+                obj2 = POP();
+                obj1 = *sp;
+                *sp = rt_binary_op(unum, obj1, obj2);
+                break;
+
+            case PYBC_COMPARE_OP:
+                unum = *ip++;
+                obj2 = POP();
+                obj1 = *sp;
+                *sp = rt_compare_op(unum, obj1, obj2);
+                break;
+
+            case PYBC_BUILD_LIST:
+                DECODE_UINT;
+                obj1 = rt_build_list(unum, sp);
+                sp += unum - 1;
+                *sp = obj1;
+                break;
+
+            case PYBC_BUILD_MAP:
+                DECODE_UINT;
+                PUSH(rt_build_map(unum));
+                break;
+
+            case PYBC_STORE_MAP:
+                sp += 2;
+                rt_store_map(sp[0], sp[-2], sp[-1]);
+                break;
+
+            case PYBC_BUILD_SET:
+                DECODE_UINT;
+                obj1 = rt_build_set(unum, sp);
+                sp += unum - 1;
+                *sp = obj1;
+                break;
+
+            case PYBC_MAKE_FUNCTION:
+                DECODE_UINT;
+                PUSH(rt_make_function_from_id(unum));
+                break;
+
+            case PYBC_CALL_FUNCTION:
+                DECODE_UINT;
+                assert((unum & 0xff00) == 0); // n_keyword
+                // switch on n_positional
+                if ((unum & 0xff) == 0) {
+                    *sp = rt_call_function_0(*sp);
+                } else if ((unum & 0xff) == 1) {
+                    obj1 = *sp++; // the single argument
+                    *sp = rt_call_function_1(*sp, obj1);
+                } else if ((unum & 0xff) == 2) {
+                    obj2 = *sp++; // the second argument
+                    obj1 = *sp++; // the first argument
+                    *sp = rt_call_function_2(*sp, obj1, obj2);
+                } else {
+                    assert(0);
+                }
+                break;
+
+            case PYBC_CALL_METHOD:
+                DECODE_UINT;
+                assert((unum & 0xff00) == 0); // n_keyword
+                // switch on n_positional
+                if ((unum & 0xff) == 0) {
+                    obj1 = *sp++; // the self object (or NULL)
+                    *sp = rt_call_method_1(*sp, obj1);
+                } else if ((unum & 0xff) == 1) {
+                    obj2 = *sp++; // the first argument
+                    obj1 = *sp++; // the self object (or NULL)
+                    *sp = rt_call_function_2(*sp, obj1, obj2);
+                } else {
+                    assert(0);
+                }
+                break;
+
+            case PYBC_RETURN_VALUE:
+                return *sp;
+
+            default:
+                printf("code %p, offset %u, byte code 0x%02x not implemented\n", code, (uint)(ip - code), op);
+                assert(0);
+                return py_const_none;
+        }
+    }
+}
diff --git a/py/bc.h b/py/bc.h
new file mode 100644
index 0000000..f09843a
--- /dev/null
+++ b/py/bc.h
@@ -0,0 +1,97 @@
+#define PYBC_LOAD_CONST_FALSE   (0x10)
+#define PYBC_LOAD_CONST_NONE    (0x11)
+#define PYBC_LOAD_CONST_TRUE    (0x12)
+#define PYBC_LOAD_CONST_SMALL_INT   (0x13) // int
+#define PYBC_LOAD_CONST_INT     (0x14) // qstr
+#define PYBC_LOAD_CONST_DEC     (0x15) // qstr
+#define PYBC_LOAD_CONST_ID      (0x16) // qstr
+#define PYBC_LOAD_CONST_BYTES   (0x17) // qstr
+#define PYBC_LOAD_CONST_STRING  (0x18) // qstr
+
+#define PYBC_LOAD_FAST_0        (0x20)
+#define PYBC_LOAD_FAST_1        (0x21)
+#define PYBC_LOAD_FAST_2        (0x22)
+#define PYBC_LOAD_FAST_N        (0x23) // uint
+#define PYBC_LOAD_NAME          (0x24) // qstr
+#define PYBC_LOAD_GLOBAL        (0x25) // qstr
+#define PYBC_LOAD_ATTR          (0x26) // qstr
+#define PYBC_LOAD_METHOD        (0x27) // qstr
+#define PYBC_LOAD_BUILD_CLASS   (0x28)
+
+#define PYBC_STORE_FAST_0       (0x30)
+#define PYBC_STORE_FAST_1       (0x31)
+#define PYBC_STORE_FAST_2       (0x32)
+#define PYBC_STORE_FAST_N       (0x33) // uint
+#define PYBC_STORE_NAME         (0x34) // qstr
+#define PYBC_STORE_GLOBAL       (0x35) // qstr
+#define PYBC_STORE_ATTR         (0x36) // qstr
+#define PYBC_STORE_LOCALS       (0x37)
+#define PYBC_STORE_SUBSCR       (0x38)
+
+#define PYBC_DELETE_FAST_N      (0x39) // uint
+#define PYBC_DELETE_NAME        (0x3a) // qstr
+#define PYBC_DELETE_GLOBAL      (0x3b) // qstr
+#define PYBC_DELETE_DEREF       (0x3c) // qstr
+#define PYBC_DELETE_ATTR        (0x3d) // qstr
+#define PYBC_DELETE_SUBSCR      (0x3e)
+
+#define PYBC_DUP_TOP            (0x40)
+#define PYBC_DUP_TOP_TWO        (0x41)
+#define PYBC_POP_TOP            (0x42)
+#define PYBC_ROT_TWO            (0x43)
+#define PYBC_ROT_THREE          (0x44)
+#define PYBC_JUMP               (0x45) // pos
+#define PYBC_POP_JUMP_IF_TRUE   (0x46) // pos
+#define PYBC_POP_JUMP_IF_FALSE  (0x47) // pos
+#define PYBC_JUMP_IF_TRUE_OR_POP    (0x48) // pos
+#define PYBC_JUMP_IF_FALSE_OR_POP   (0x49) // pos
+#define PYBC_SETUP_LOOP         (0x4a) // pos
+#define PYBC_BREAK_LOOP         (0x4b) // pos
+#define PYBC_CONTINUE_LOOP      (0x4c) // pos
+#define PYBC_SETUP_WITH         (0x4d) // pos
+#define PYBC_WITH_CLEANUP       (0x4e)
+#define PYBC_SETUP_EXCEPT       (0x4f) // pos
+#define PYBC_SETUP_FINALLY      (0x50) // pos
+#define PYBC_END_FINALLY        (0x51)
+#define PYBC_GET_ITER           (0x52)
+#define PYBC_FOR_ITER           (0x53) // pos
+#define PYBC_POP_BLOCK          (0x54)
+#define PYBC_POP_EXCEPT         (0x55)
+
+#define PYBC_UNARY_OP           (0x60) // byte
+#define PYBC_BINARY_OP          (0x61) // byte
+#define PYBC_COMPARE_OP         (0x62) // byte
+
+#define PYBC_BUILD_TUPLE        (0x70) // uint
+#define PYBC_BUILD_LIST         (0x71) // uint
+#define PYBC_LIST_APPEND        (0x72) // uint
+#define PYBC_BUILD_MAP          (0x73) // uint
+#define PYBC_STORE_MAP          (0x74)
+#define PYBC_MAP_ADD            (0x75) // uint
+#define PYBC_BUILD_SET          (0x76) // uint
+#define PYBC_SET_ADD            (0x77) // uint
+#define PYBC_BUILD_SLICE        (0x78) // uint
+#define PYBC_UNPACK_SEQUENCE    (0x79) // uint
+#define PYBC_UNPACK_EX          (0x7a) // uint
+
+#define PYBC_RETURN_VALUE       (0x80)
+#define PYBC_RAISE_VARARGS      (0x81) // uint
+#define PYBC_YIELD_VALUE        (0x82)
+#define PYBC_YIELD_FROM         (0x83)
+
+#define PYBC_MAKE_FUNCTION      (0x90) // uint
+#define PYBC_MAKE_CLOSURE       (0x91) // uint?
+#define PYBC_CALL_FUNCTION      (0x92) // uint
+#define PYBC_CALL_FUNCTION_VAR  (0x93) // uint
+#define PYBC_CALL_FUNCTION_KW   (0x94) // uint
+#define PYBC_CALL_FUNCTION_VAR_KW   (0x95) // uint
+#define PYBC_CALL_METHOD        (0x96) // uint
+#define PYBC_CALL_METHOD_VAR    (0x97) // uint
+#define PYBC_CALL_METHOD_KW     (0x98) // uint
+#define PYBC_CALL_METHOD_VAR_KW (0x99) // uint
+
+#define PYBC_IMPORT_NAME (0xe0)
+#define PYBC_IMPORT_FROM (0xe1)
+#define PYBC_IMPORT_STAR (0xe2)
+
+py_obj_t py_execute_byte_code(byte *code, uint len, py_obj_t *args, uint n_args);
diff --git a/py/compile.c b/py/compile.c
new file mode 100644
index 0000000..0e6ce44
--- /dev/null
+++ b/py/compile.c
@@ -0,0 +1,2510 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "scope.h"
+#include "compile.h"
+#include "runtime.h"
+#include "emit.h"
+
+// TODO need to mangle __attr names
+
+typedef enum {
+    PN_none = 0,
+#define DEF_RULE(rule, comp, kind, arg...) PN_##rule,
+#include "grammar.h"
+#undef DEF_RULE
+    PN_maximum_number_of,
+} pn_kind_t;
+
+#define EMIT(fun, arg...) (emit_##fun(comp->emit, ##arg))
+
+typedef struct _compiler_t {
+    qstr qstr___class__;
+    qstr qstr___locals__;
+    qstr qstr___name__;
+    qstr qstr___module__;
+    qstr qstr___qualname__;
+    qstr qstr___doc__;
+    qstr qstr_assertion_error;
+
+    pass_kind_t pass;
+
+    int break_label;
+    int continue_label;
+    int except_nest_level;
+
+    int n_arg_keyword;
+    bool have_star_arg;
+    bool have_dbl_star_arg;
+    bool have_bare_star;
+    int param_pass;
+    int param_pass_num_dict_params;
+    int param_pass_num_default_params;
+
+    scope_t *scope_head;
+    scope_t *scope_cur;
+
+    emitter_t *emit;
+} compiler_t;
+
+py_parse_node_t fold_constants(py_parse_node_t pn) {
+    if (PY_PARSE_NODE_IS_STRUCT(pn)) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+
+        // fold arguments first
+        for (int i = 0; i < n; i++) {
+            pns->nodes[i] = fold_constants(pns->nodes[i]);
+        }
+
+        switch (PY_PARSE_NODE_STRUCT_KIND(pns)) {
+            case PN_shift_expr:
+                if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+                    int arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+                    int arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+                    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_DBL_LESS)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 << arg1); // XXX can overflow; enabled only to compare with CPython
+                    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_DBL_MORE)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 >> arg1);
+                    } else {
+                        // shouldn't happen
+                        assert(0);
+                    }
+                }
+                break;
+
+            case PN_arith_expr:
+                // XXX can overflow; enabled only to compare with CPython
+                if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+                    int arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+                    int arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+                    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_PLUS)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 + arg1);
+                    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_MINUS)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 - arg1);
+                    } else {
+                        // shouldn't happen
+                        assert(0);
+                    }
+                }
+                break;
+
+            case PN_term:
+                // XXX can overflow; enabled only to compare with CPython
+                if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+                    int arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+                    int arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+                    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_STAR)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 * arg1);
+                    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_SLASH)) {
+                        ; // pass
+                    //} else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_)) {
+                        //pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 - arg1);
+                    } else {
+                        // shouldn't happen
+                        assert(0);
+                    }
+                }
+                break;
+
+            case PN_factor_2:
+                if (PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[1])) {
+                    machine_int_t arg = PY_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
+                    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_PLUS)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg);
+                    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_MINUS)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, -arg);
+                    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_TILDE)) {
+                        pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, ~arg);
+                    } else {
+                        // shouldn't happen
+                        assert(0);
+                    }
+                }
+                break;
+
+            case PN_power:
+                // XXX can overflow; enabled only to compare with CPython
+                if (PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_NULL(pns->nodes[1]) && !PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+                    py_parse_node_struct_t* pns2 = (py_parse_node_struct_t*)pns->nodes[2];
+                    if (PY_PARSE_NODE_IS_SMALL_INT(pns2->nodes[0])) {
+                        int power = PY_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
+                        if (power >= 0) {
+                            int ans = 1;
+                            int base = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+                            for (; power > 0; power--) {
+                                ans *= base;
+                            }
+                            pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, ans);
+                        }
+                    }
+                }
+                break;
+        }
+    }
+
+    return pn;
+}
+
+void compile_node(compiler_t *comp, py_parse_node_t pn);
+
+scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, py_parse_node_t pn) {
+    scope_t *scope = scope_new(kind, pn);
+    scope->parent = comp->scope_cur;
+    scope->next = NULL;
+    if (comp->scope_head == NULL) {
+        comp->scope_head = scope;
+    } else {
+        scope_t *s = comp->scope_head;
+        while (s->next != NULL) {
+            s = s->next;
+        }
+        s->next = scope;
+    }
+    return scope;
+}
+
+int list_len(py_parse_node_t pn, int pn_kind) {
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        return 0;
+    } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
+        return 1;
+    } else {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
+            return 1;
+        } else {
+            return PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        }
+    }
+}
+
+void apply_to_single_or_list(compiler_t *comp, py_parse_node_t pn, int pn_list_kind, void (*f)(compiler_t*, py_parse_node_t)) {
+    if (PY_PARSE_NODE_IS_STRUCT(pn) && PY_PARSE_NODE_STRUCT_KIND((py_parse_node_struct_t*)pn) == pn_list_kind) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        for (int i = 0; i < num_nodes; i++) {
+            f(comp, pns->nodes[i]);
+        }
+    } else if (!PY_PARSE_NODE_IS_NULL(pn)) {
+        f(comp, pn);
+    }
+}
+
+int list_get(py_parse_node_t *pn, int pn_kind, py_parse_node_t **nodes) {
+    if (PY_PARSE_NODE_IS_NULL(*pn)) {
+        *nodes = NULL;
+        return 0;
+    } else if (PY_PARSE_NODE_IS_LEAF(*pn)) {
+        *nodes = pn;
+        return 1;
+    } else {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)(*pn);
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
+            *nodes = pn;
+            return 1;
+        } else {
+            *nodes = pns->nodes;
+            return PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        }
+    }
+}
+
+void compile_do_nothing(compiler_t *comp, py_parse_node_struct_t *pns) {
+}
+
+void compile_generic_all_nodes(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < num_nodes; i++) {
+        compile_node(comp, pns->nodes[i]);
+    }
+}
+
+bool c_tuple_is_const(py_parse_node_t pn) {
+    if (!PY_PARSE_NODE_IS_LEAF(pn)) {
+        return false;
+    }
+    if (PY_PARSE_NODE_IS_ID(pn)) {
+        return false;
+    }
+    return true;
+}
+
+void c_tuple_emit_const(compiler_t *comp, py_parse_node_t pn) {
+    assert(PY_PARSE_NODE_IS_LEAF(pn));
+    int arg = PY_PARSE_NODE_LEAF_ARG(pn);
+    switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
+        case PY_PARSE_NODE_ID: assert(0);
+        case PY_PARSE_NODE_SMALL_INT: EMIT(load_const_verbatim_int, arg); break;
+        case PY_PARSE_NODE_INTEGER: EMIT(load_const_verbatim_str, qstr_str(arg)); break;
+        case PY_PARSE_NODE_DECIMAL: EMIT(load_const_verbatim_str, qstr_str(arg)); break;
+        case PY_PARSE_NODE_STRING: EMIT(load_const_verbatim_quoted_str, arg, false); break;
+        case PY_PARSE_NODE_BYTES: EMIT(load_const_verbatim_quoted_str, arg, true); break;
+        case PY_PARSE_NODE_TOKEN:
+            switch (arg) {
+                case PY_TOKEN_KW_FALSE: EMIT(load_const_verbatim_str, "False"); break;
+                case PY_TOKEN_KW_NONE: EMIT(load_const_verbatim_str, "None"); break;
+                case PY_TOKEN_KW_TRUE: EMIT(load_const_verbatim_str, "True"); break;
+                default: assert(0);
+            }
+            break;
+        default: assert(0);
+    }
+}
+
+// funnelling all tuple creations through this function and all this constant stuff is purely to agree with CPython
+void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
+    int n = 0;
+    if (pns_list != NULL) {
+        n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
+    }
+    int total = n;
+    bool is_const = true;
+    if (!PY_PARSE_NODE_IS_NULL(pn)) {
+        total += 1;
+        if (!c_tuple_is_const(pn)) {
+            is_const = false;
+        }
+    }
+    for (int i = 0; i < n; i++) {
+        if (!c_tuple_is_const(pns_list->nodes[i])) {
+            is_const = false;
+            break;
+        }
+    }
+    if (total > 0 && is_const) {
+        bool need_comma = false;
+        EMIT(load_const_verbatim_start);
+        EMIT(load_const_verbatim_str, "(");
+        if (!PY_PARSE_NODE_IS_NULL(pn)) {
+            c_tuple_emit_const(comp, pn);
+            need_comma = true;
+        }
+        for (int i = 0; i < n; i++) {
+            if (need_comma) {
+                EMIT(load_const_verbatim_str, ", ");
+            }
+            c_tuple_emit_const(comp, pns_list->nodes[i]);
+            need_comma = true;
+        }
+        if (total == 1) {
+            EMIT(load_const_verbatim_str, ",)");
+        } else {
+            EMIT(load_const_verbatim_str, ")");
+        }
+        EMIT(load_const_verbatim_end);
+    } else {
+        if (!PY_PARSE_NODE_IS_NULL(pn)) {
+            compile_node(comp, pn);
+        }
+        for (int i = 0; i < n; i++) {
+            compile_node(comp, pns_list->nodes[i]);
+        }
+        EMIT(build_tuple, total);
+    }
+}
+
+void compile_generic_tuple(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // a simple tuple expression
+    /*
+    int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < n; i++) {
+        compile_node(comp, pns->nodes[i]);
+    }
+    EMIT(build_tuple, n);
+    */
+    c_tuple(comp, PY_PARSE_NODE_NULL, pns);
+}
+
+bool node_is_const_false(py_parse_node_t pn) {
+    return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_FALSE);
+    // untested: || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
+}
+
+bool node_is_const_true(py_parse_node_t pn) {
+    return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_TRUE) || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
+}
+
+// having c_if_cond_2 and the is_nested variable is purely to match with CPython, which doesn't fully optimise not's
+void c_if_cond_2(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label, bool is_nested) {
+    if (node_is_const_false(pn)) {
+        if (jump_if == false) {
+            EMIT(jump, label);
+        }
+        return;
+    } else if (node_is_const_true(pn)) {
+        if (jump_if == true) {
+            EMIT(jump, label);
+        }
+        return;
+    } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
+            if (jump_if == false) {
+                int label2 = EMIT(label_new);
+                for (int i = 0; i < n - 1; i++) {
+                    c_if_cond_2(comp, pns->nodes[i], true, label2, true);
+                }
+                c_if_cond_2(comp, pns->nodes[n - 1], false, label, true);
+                EMIT(label_assign, label2);
+            } else {
+                for (int i = 0; i < n; i++) {
+                    c_if_cond_2(comp, pns->nodes[i], true, label, true);
+                }
+            }
+            return;
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
+            if (jump_if == false) {
+                for (int i = 0; i < n; i++) {
+                    c_if_cond_2(comp, pns->nodes[i], false, label, true);
+                }
+            } else {
+                int label2 = EMIT(label_new);
+                for (int i = 0; i < n - 1; i++) {
+                    c_if_cond_2(comp, pns->nodes[i], false, label2, true);
+                }
+                c_if_cond_2(comp, pns->nodes[n - 1], true, label, true);
+                EMIT(label_assign, label2);
+            }
+            return;
+        } else if (!is_nested && PY_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
+            c_if_cond_2(comp, pns->nodes[0], !jump_if, label, true);
+            return;
+        }
+    }
+
+    // nothing special, fall back to default compiling for node and jump
+    compile_node(comp, pn);
+    if (jump_if == false) {
+        EMIT(pop_jump_if_false, label);
+    } else {
+        EMIT(pop_jump_if_true, label);
+    }
+}
+
+void c_if_cond(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label) {
+    c_if_cond_2(comp, pn, jump_if, label, false);
+}
+
+typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
+void c_assign(compiler_t *comp, py_parse_node_t pn, assign_kind_t kind);
+
+void c_assign_power(compiler_t *comp, py_parse_node_struct_t *pns, assign_kind_t assign_kind) {
+    if (assign_kind != ASSIGN_AUG_STORE) {
+        compile_node(comp, pns->nodes[0]);
+    }
+
+    if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+        py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
+        if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
+            int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+            if (assign_kind != ASSIGN_AUG_STORE) {
+                for (int i = 0; i < n - 1; i++) {
+                    compile_node(comp, pns1->nodes[i]);
+                }
+            }
+            assert(PY_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
+            pns1 = (py_parse_node_struct_t*)pns1->nodes[n - 1];
+        }
+        if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
+            printf("SyntaxError: can't assign to function call\n");
+            return;
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
+            if (assign_kind == ASSIGN_AUG_STORE) {
+                EMIT(rot_three);
+                EMIT(store_subscr);
+            } else {
+                compile_node(comp, pns1->nodes[0]);
+                if (assign_kind == ASSIGN_AUG_LOAD) {
+                    EMIT(dup_top_two);
+                    EMIT(binary_op, RT_BINARY_OP_SUBSCR);
+                } else {
+                    EMIT(store_subscr);
+                }
+            }
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
+            assert(PY_PARSE_NODE_IS_ID(pns1->nodes[0]));
+            if (assign_kind == ASSIGN_AUG_LOAD) {
+                EMIT(dup_top);
+                EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+            } else {
+                if (assign_kind == ASSIGN_AUG_STORE) {
+                    EMIT(rot_two);
+                }
+                EMIT(store_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+            }
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+
+    if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+        // SyntaxError, cannot assign
+        assert(0);
+    }
+}
+
+void c_assign_tuple(compiler_t *comp, int n, py_parse_node_t *nodes) {
+    assert(n >= 0);
+    int have_star_index = -1;
+    for (int i = 0; i < n; i++) {
+        if (PY_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_star_expr)) {
+            if (have_star_index < 0) {
+                EMIT(unpack_ex, i, n - i - 1);
+                have_star_index = i;
+            } else {
+                printf("SyntaxError: two starred expressions in assignment\n");
+                return;
+            }
+        }
+    }
+    if (have_star_index < 0) {
+        EMIT(unpack_sequence, n);
+    }
+    for (int i = 0; i < n; i++) {
+        if (i == have_star_index) {
+            c_assign(comp, ((py_parse_node_struct_t*)nodes[i])->nodes[0], ASSIGN_STORE);
+        } else {
+            c_assign(comp, nodes[i], ASSIGN_STORE);
+        }
+    }
+}
+
+// assigns top of stack to pn
+void c_assign(compiler_t *comp, py_parse_node_t pn, assign_kind_t assign_kind) {
+    tail_recursion:
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        assert(0);
+    } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
+        if (PY_PARSE_NODE_IS_ID(pn)) {
+            int arg = PY_PARSE_NODE_LEAF_ARG(pn);
+            switch (assign_kind) {
+                case ASSIGN_STORE:
+                case ASSIGN_AUG_STORE:
+                    emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, arg);
+                    break;
+                case ASSIGN_AUG_LOAD:
+                    emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, arg);
+                    break;
+            }
+        } else {
+            printf("SyntaxError: can't assign to literal\n");
+            return;
+        }
+    } else {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        switch (PY_PARSE_NODE_STRUCT_KIND(pns)) {
+            case PN_power:
+                // lhs is an index or attribute
+                c_assign_power(comp, pns, assign_kind);
+                break;
+
+            case PN_testlist_star_expr:
+            case PN_exprlist:
+                // lhs is a tuple
+                if (assign_kind != ASSIGN_STORE) {
+                    goto bad_aug;
+                }
+                c_assign_tuple(comp, PY_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
+                break;
+
+            case PN_atom_paren:
+                // lhs is something in parenthesis
+                if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+                    // empty tuple
+                    printf("SyntaxError: can't assign to ()\n");
+                    return;
+                } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+                    pns = (py_parse_node_struct_t*)pns->nodes[0];
+                    goto testlist_comp;
+                } else {
+                    // parenthesis around 1 item, is just that item
+                    pn = pns->nodes[0];
+                    goto tail_recursion;
+                }
+                break;
+
+            case PN_atom_bracket:
+                // lhs is something in brackets
+                if (assign_kind != ASSIGN_STORE) {
+                    goto bad_aug;
+                }
+                if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+                    // empty list, assignment allowed
+                    c_assign_tuple(comp, 0, NULL);
+                } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+                    pns = (py_parse_node_struct_t*)pns->nodes[0];
+                    goto testlist_comp;
+                } else {
+                    // brackets around 1 item
+                    c_assign_tuple(comp, 1, &pns->nodes[0]);
+                }
+                break;
+
+            default:
+                printf("unknown assign, %u\n", (uint)PY_PARSE_NODE_STRUCT_KIND(pns));
+                assert(0);
+        }
+        return;
+
+        testlist_comp:
+        // lhs is a sequence
+        if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+            py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
+            if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
+                // sequence of one item, with trailing comma
+                assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[0]));
+                c_assign_tuple(comp, 1, &pns->nodes[0]);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
+                // sequence of many items
+                // TODO call c_assign_tuple instead
+                int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns2);
+                EMIT(unpack_sequence, 1 + n);
+                c_assign(comp, pns->nodes[0], ASSIGN_STORE);
+                for (int i = 0; i < n; i++) {
+                    c_assign(comp, pns2->nodes[i], ASSIGN_STORE);
+                }
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
+                // TODO not implemented
+                assert(0);
+            } else {
+                // sequence with 2 items
+                goto sequence_with_2_items;
+            }
+        } else {
+            // sequence with 2 items
+            sequence_with_2_items:
+            c_assign_tuple(comp, 2, pns->nodes);
+        }
+        return;
+    }
+    return;
+
+    bad_aug:
+    printf("SyntaxError: illegal expression for augmented assignment\n");
+}
+
+// stuff for lambda and comprehensions and generators
+void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_dict_params, int n_default_params) {
+    // make closed over variables, if any
+    int nfree = 0;
+    if (comp->scope_cur->kind != SCOPE_MODULE) {
+        for (int i = 0; i < this_scope->id_info_len; i++) {
+            id_info_t *id_info = &this_scope->id_info[i];
+            if (id_info->kind == ID_INFO_KIND_FREE) {
+                EMIT(load_closure, id_info->qstr);
+                nfree += 1;
+            }
+        }
+    }
+    if (nfree > 0) {
+        EMIT(build_tuple, nfree);
+    }
+
+    // make the function/closure
+    if (nfree == 0) {
+        EMIT(make_function, this_scope, n_dict_params, n_default_params);
+    } else {
+        EMIT(make_closure, this_scope, n_dict_params, n_default_params);
+    }
+}
+
+void compile_funcdef_param(compiler_t *comp, py_parse_node_t pn) {
+    assert(PY_PARSE_NODE_IS_STRUCT(pn));
+    py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+    if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_typedargslist_name) {
+        if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+            // this parameter has a default value
+            // in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why
+            if (comp->have_bare_star) {
+                comp->param_pass_num_dict_params += 1;
+                if (comp->param_pass == 1) {
+                    EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+                    compile_node(comp, pns->nodes[2]);
+                }
+            } else {
+                comp->param_pass_num_default_params += 1;
+                if (comp->param_pass == 2) {
+                    compile_node(comp, pns->nodes[2]);
+                }
+            }
+        }
+    } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_typedargslist_star) {
+        if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+            // bare star
+            comp->have_bare_star = true;
+        }
+    }
+}
+
+// leaves function object on stack
+// returns function name
+qstr compile_funcdef_helper(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->pass == PASS_1) {
+        // create a new scope for this function
+        scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (py_parse_node_t)pns);
+        // store the function scope so the compiling function can use it at each pass
+        pns->nodes[4] = (py_parse_node_t)s;
+    }
+
+    // save variables (probably don't need to do this, since we can't have nested definitions..?)
+    bool old_have_bare_star = comp->have_bare_star;
+    int old_param_pass = comp->param_pass;
+    int old_param_pass_num_dict_params = comp->param_pass_num_dict_params;
+    int old_param_pass_num_default_params = comp->param_pass_num_default_params;
+
+    // compile default parameters
+    comp->have_bare_star = false;
+    comp->param_pass = 1; // pass 1 does any default parameters after bare star
+    comp->param_pass_num_dict_params = 0;
+    comp->param_pass_num_default_params = 0;
+    apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_funcdef_param);
+    comp->have_bare_star = false;
+    comp->param_pass = 2; // pass 2 does any default parameters before bare star
+    comp->param_pass_num_dict_params = 0;
+    comp->param_pass_num_default_params = 0;
+    apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_funcdef_param);
+
+    // get the scope for this function
+    scope_t *fscope = (scope_t*)pns->nodes[4];
+
+    // make the function
+    close_over_variables_etc(comp, fscope, comp->param_pass_num_dict_params, comp->param_pass_num_default_params);
+
+    // restore variables
+    comp->have_bare_star = old_have_bare_star;
+    comp->param_pass = old_param_pass;
+    comp->param_pass_num_dict_params = old_param_pass_num_dict_params;
+    comp->param_pass_num_default_params = old_param_pass_num_default_params;
+
+    // return its name (the 'f' in "def f(...):")
+    return fscope->simple_name;
+}
+
+// leaves class object on stack
+// returns class name
+qstr compile_classdef_helper(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->pass == PASS_1) {
+        // create a new scope for this class
+        scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (py_parse_node_t)pns);
+        // store the class scope so the compiling function can use it at each pass
+        pns->nodes[3] = (py_parse_node_t)s;
+    }
+
+    EMIT(load_build_class);
+
+    // scope for this class
+    scope_t *cscope = (scope_t*)pns->nodes[3];
+
+    // compile the class
+    close_over_variables_etc(comp, cscope, 0, 0);
+
+    // get its name
+    EMIT(load_const_id, cscope->simple_name);
+
+    // nodes[1] has parent classes, if any
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+        // no parent classes
+        EMIT(call_function, 2, 0, false, false);
+    } else {
+        // have a parent class or classes
+        // TODO what if we have, eg, *a or **a in the parent list?
+        compile_node(comp, pns->nodes[1]);
+        EMIT(call_function, 2 + list_len(pns->nodes[1], PN_arglist), 0, false, false);
+    }
+
+    // return its name (the 'C' in class C(...):")
+    return cscope->simple_name;
+}
+
+void compile_decorated(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // get the list of decorators
+    py_parse_node_t *nodes;
+    int n = list_get(&pns->nodes[0], PN_decorators, &nodes);
+
+    // load each decorator
+    for (int i = 0; i < n; i++) {
+        assert(PY_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
+        py_parse_node_struct_t *pns_decorator = (py_parse_node_struct_t*)nodes[i];
+        py_parse_node_t *nodes2;
+        int n2 = list_get(&pns_decorator->nodes[0], PN_dotted_name, &nodes2);
+        compile_node(comp, nodes2[0]);
+        for (int i = 1; i < n2; i++) {
+            EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(nodes2[i]));
+        }
+        if (!PY_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
+            // first call the function with these arguments
+            compile_node(comp, pns_decorator->nodes[1]);
+        }
+    }
+
+    // compile the body (funcdef or classdef) and get its name
+    py_parse_node_struct_t *pns_body = (py_parse_node_struct_t*)pns->nodes[1];
+    qstr body_name = 0;
+    if (PY_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
+        body_name = compile_funcdef_helper(comp, pns_body);
+    } else if (PY_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef) {
+        body_name = compile_classdef_helper(comp, pns_body);
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+
+    // call each decorator
+    for (int i = 0; i < n; i++) {
+        EMIT(call_function, 1, 0, false, false);
+    }
+
+    // store func/class object into name
+    emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, body_name);
+}
+
+void compile_funcdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+    qstr fname = compile_funcdef_helper(comp, pns);
+    // store function object into function name
+    emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, fname);
+}
+
+void c_del_stmt(compiler_t *comp, py_parse_node_t pn) {
+    if (PY_PARSE_NODE_IS_ID(pn)) {
+        emit_common_delete_id(comp->pass, comp->scope_cur, comp->emit, PY_PARSE_NODE_LEAF_ARG(pn));
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+
+        compile_node(comp, pns->nodes[0]); // base of the power node
+
+        if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+            py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
+            if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
+                int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+                for (int i = 0; i < n - 1; i++) {
+                    compile_node(comp, pns1->nodes[i]);
+                }
+                assert(PY_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
+                pns1 = (py_parse_node_struct_t*)pns1->nodes[n - 1];
+            }
+            if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
+                // SyntaxError: can't delete a function call
+                assert(0);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
+                compile_node(comp, pns1->nodes[0]);
+                EMIT(delete_subscr);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
+                assert(PY_PARSE_NODE_IS_ID(pns1->nodes[0]));
+                EMIT(delete_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+            } else {
+                // shouldn't happen
+                assert(0);
+            }
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+
+        if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+            // SyntaxError, cannot delete
+            assert(0);
+        }
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
+        pn = ((py_parse_node_struct_t*)pn)->nodes[0];
+        if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp)) {
+            py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+            // TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
+
+            if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+                py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
+                if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
+                    // sequence of one item, with trailing comma
+                    assert(PY_PARSE_NODE_IS_NULL(pns1->nodes[0]));
+                    c_del_stmt(comp, pns->nodes[0]);
+                } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
+                    // sequence of many items
+                    int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+                    c_del_stmt(comp, pns->nodes[0]);
+                    for (int i = 0; i < n; i++) {
+                        c_del_stmt(comp, pns1->nodes[i]);
+                    }
+                } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
+                    // TODO not implemented; can't del comprehension?
+                    assert(0);
+                } else {
+                    // sequence with 2 items
+                    goto sequence_with_2_items;
+                }
+            } else {
+                // sequence with 2 items
+                sequence_with_2_items:
+                c_del_stmt(comp, pns->nodes[0]);
+                c_del_stmt(comp, pns->nodes[1]);
+            }
+        } else {
+            // tuple with 1 element
+            c_del_stmt(comp, pn);
+        }
+    } else {
+        // not implemented
+        assert(0);
+    }
+}
+
+void compile_del_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
+}
+
+void compile_break_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->break_label == 0) {
+        printf("ERROR: cannot break from here\n");
+    }
+    EMIT(break_loop, comp->break_label);
+}
+
+void compile_continue_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->continue_label == 0) {
+        printf("ERROR: cannot continue from here\n");
+    }
+    if (comp->except_nest_level > 0) {
+        EMIT(continue_loop, comp->continue_label);
+    } else {
+        EMIT(jump, comp->continue_label);
+    }
+}
+
+void compile_return_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
+        // special case when returning an if-expression; to match CPython optimisation
+        py_parse_node_struct_t *pns_test_if_expr = (py_parse_node_struct_t*)pns->nodes[0];
+        py_parse_node_struct_t *pns_test_if_else = (py_parse_node_struct_t*)pns_test_if_expr->nodes[1];
+
+        int l_fail = EMIT(label_new);
+        c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
+        compile_node(comp, pns_test_if_expr->nodes[0]); // success value
+        EMIT(return_value);
+        EMIT(label_assign, l_fail);
+        compile_node(comp, pns_test_if_else->nodes[1]); // failure value
+    } else {
+        compile_node(comp, pns->nodes[0]);
+    }
+    EMIT(return_value);
+}
+
+void compile_yield_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_node(comp, pns->nodes[0]);
+    EMIT(pop_top);
+}
+
+void compile_raise_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+        // raise
+        EMIT(raise_varargs, 0);
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
+        // raise x from y
+        pns = (py_parse_node_struct_t*)pns->nodes[0];
+        compile_node(comp, pns->nodes[0]);
+        compile_node(comp, pns->nodes[1]);
+        EMIT(raise_varargs, 2);
+    } else {
+        // raise x
+        compile_node(comp, pns->nodes[0]);
+        EMIT(raise_varargs, 1);
+    }
+}
+
+// q1 holds the base, q2 the full name
+// eg   a -> q1=q2=a
+//      a.b.c -> q1=a, q2=a.b.c
+void do_import_name(compiler_t *comp, py_parse_node_t pn, qstr *q1, qstr *q2) {
+    bool is_as = false;
+    if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        // a name of the form x as y; unwrap it
+        *q1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
+        pn = pns->nodes[0];
+        is_as = true;
+    }
+    if (PY_PARSE_NODE_IS_ID(pn)) {
+        // just a simple name
+        *q2 = PY_PARSE_NODE_LEAF_ARG(pn);
+        if (!is_as) {
+            *q1 = *q2;
+        }
+        EMIT(import_name, *q2);
+    } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dotted_name) {
+            // a name of the form a.b.c
+            if (!is_as) {
+                *q1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+            }
+            int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+            int len = n - 1;
+            for (int i = 0; i < n; i++) {
+                len += strlen(qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
+            }
+            char *str = m_new(char, len + 1);
+            str[0] = 0;
+            for (int i = 0; i < n; i++) {
+                if (i > 0) {
+                    strcat(str, ".");
+                }
+                strcat(str, qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
+            }
+            *q2 = qstr_from_str_take(str);
+            EMIT(import_name, *q2);
+            if (is_as) {
+                for (int i = 1; i < n; i++) {
+                    EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+                }
+            }
+        } else {
+            // TODO not implemented
+            assert(0);
+        }
+    } else {
+        // TODO not implemented
+        assert(0);
+    }
+}
+
+void compile_dotted_as_name(compiler_t *comp, py_parse_node_t pn) {
+    EMIT(load_const_small_int, 0); // ??
+    EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+    qstr q1, q2;
+    do_import_name(comp, pn, &q1, &q2);
+    emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, q1);
+}
+
+void compile_import_name(compiler_t *comp, py_parse_node_struct_t *pns) {
+    apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
+}
+
+void compile_import_from(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_STAR)) {
+        EMIT(load_const_small_int, 0); // what's this for??
+        EMIT(load_const_verbatim_start);
+        EMIT(load_const_verbatim_str, "('*',)");
+        EMIT(load_const_verbatim_end);
+        qstr dummy_q, id1;
+        do_import_name(comp, pns->nodes[0], &dummy_q, &id1);
+        EMIT(import_star);
+    } else {
+        py_parse_node_t *pn_nodes;
+        int n = list_get(&pns->nodes[1], PN_import_as_names, &pn_nodes);
+
+        EMIT(load_const_small_int, 0); // what's this for??
+        EMIT(load_const_verbatim_start);
+        EMIT(load_const_verbatim_str, "(");
+        for (int i = 0; i < n; i++) {
+            assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
+            py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pn_nodes[i];
+            qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
+            if (i > 0) {
+                EMIT(load_const_verbatim_str, ", ");
+            }
+            EMIT(load_const_verbatim_str, "'");
+            EMIT(load_const_verbatim_str, qstr_str(id2));
+            EMIT(load_const_verbatim_str, "'");
+        }
+        if (n == 1) {
+            EMIT(load_const_verbatim_str, ",");
+        }
+        EMIT(load_const_verbatim_str, ")");
+        EMIT(load_const_verbatim_end);
+        qstr dummy_q, id1;
+        do_import_name(comp, pns->nodes[0], &dummy_q, &id1);
+        for (int i = 0; i < n; i++) {
+            assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
+            py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pn_nodes[i];
+            qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
+            EMIT(import_from, id2);
+            if (PY_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
+                emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, id2);
+            } else {
+                emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
+            }
+        }
+        EMIT(pop_top);
+    }
+}
+
+void compile_global_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+        emit_common_declare_global(comp->pass, comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+    } else {
+        pns = (py_parse_node_struct_t*)pns->nodes[0];
+        int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        for (int i = 0; i < num_nodes; i++) {
+            emit_common_declare_global(comp->pass, comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+        }
+    }
+}
+
+void compile_nonlocal_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+        emit_common_declare_nonlocal(comp->pass, comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+    } else {
+        pns = (py_parse_node_struct_t*)pns->nodes[0];
+        int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+        for (int i = 0; i < num_nodes; i++) {
+            emit_common_declare_nonlocal(comp->pass, comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+        }
+    }
+}
+
+void compile_assert_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int l_end = EMIT(label_new);
+    c_if_cond(comp, pns->nodes[0], true, l_end);
+    emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, comp->qstr_assertion_error);
+    if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+        // assertion message
+        compile_node(comp, pns->nodes[1]);
+        EMIT(call_function, 1, 0, false, false);
+    }
+    EMIT(raise_varargs, 1);
+    EMIT(label_assign, l_end);
+}
+
+void compile_if_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // TODO proper and/or short circuiting
+
+    int l_end = EMIT(label_new);
+
+    int l_fail = EMIT(label_new);
+    c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
+
+    compile_node(comp, pns->nodes[1]); // if block
+    //if (!(PY_PARSE_NODE_IS_NULL(pns->nodes[2]) && PY_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython
+        // jump over elif/else blocks if they exist
+        if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython
+            EMIT(jump, l_end);
+        }
+    //}
+    EMIT(label_assign, l_fail);
+
+    if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+        // compile elif blocks
+
+        py_parse_node_struct_t *pns_elif = (py_parse_node_struct_t*)pns->nodes[2];
+
+        if (PY_PARSE_NODE_STRUCT_KIND(pns_elif) == PN_if_stmt_elif_list) {
+            // multiple elif blocks
+
+            int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_elif);
+            for (int i = 0; i < n; i++) {
+                py_parse_node_struct_t *pns_elif2 = (py_parse_node_struct_t*)pns_elif->nodes[i];
+                l_fail = EMIT(label_new);
+                c_if_cond(comp, pns_elif2->nodes[0], false, l_fail); // elif condition
+
+                compile_node(comp, pns_elif2->nodes[1]); // elif block
+                if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython
+                    EMIT(jump, l_end);
+                }
+                EMIT(label_assign, l_fail);
+            }
+
+        } else {
+            // a single elif block
+
+            l_fail = EMIT(label_new);
+            c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
+
+            compile_node(comp, pns_elif->nodes[1]); // elif block
+            if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython
+                EMIT(jump, l_end);
+            }
+            EMIT(label_assign, l_fail);
+        }
+    }
+
+    // compile else block
+    compile_node(comp, pns->nodes[3]); // can be null
+
+    EMIT(label_assign, l_end);
+}
+
+void compile_while_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int old_break_label = comp->break_label;
+    int old_continue_label = comp->continue_label;
+
+    int done_label = EMIT(label_new);
+    int end_label = EMIT(label_new);
+    int break_label = EMIT(label_new);
+    int continue_label = EMIT(label_new);
+
+    comp->break_label = break_label;
+    comp->continue_label = continue_label;
+
+    EMIT(setup_loop, end_label);
+    EMIT(label_assign, continue_label);
+    c_if_cond(comp, pns->nodes[0], false, done_label); // condition
+    compile_node(comp, pns->nodes[1]); // body
+    if (!emit_last_emit_was_return_value(comp->emit)) {
+        EMIT(jump, continue_label);
+    }
+    EMIT(label_assign, done_label);
+
+    // break/continue apply to outer loop (if any) in the else block
+    comp->break_label = old_break_label;
+    comp->continue_label = old_continue_label;
+
+    // CPython does not emit POP_BLOCK if the condition was a constant; don't undertand why
+    // this is a small hack to agree with CPython
+    if (!node_is_const_true(pns->nodes[0])) {
+        EMIT(pop_block);
+    }
+
+    compile_node(comp, pns->nodes[2]); // else
+
+    EMIT(label_assign, break_label);
+    EMIT(label_assign, end_label);
+}
+
+void compile_for_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int old_break_label = comp->break_label;
+    int old_continue_label = comp->continue_label;
+
+    int for_label = EMIT(label_new);
+    int pop_label = EMIT(label_new);
+    int end_label = EMIT(label_new);
+
+    int break_label = EMIT(label_new);
+
+    comp->continue_label = for_label;
+    comp->break_label = break_label;
+
+    EMIT(setup_loop, end_label);
+    compile_node(comp, pns->nodes[1]); // iterator
+    EMIT(get_iter);
+    EMIT(label_assign, for_label);
+    EMIT(for_iter, pop_label);
+    c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
+    compile_node(comp, pns->nodes[2]); // body
+    if (!emit_last_emit_was_return_value(comp->emit)) {
+        EMIT(jump, for_label);
+    }
+    EMIT(label_assign, pop_label);
+    EMIT(for_iter_end);
+
+    // break/continue apply to outer loop (if any) in the else block
+    comp->break_label = old_break_label;
+    comp->continue_label = old_continue_label;
+
+    EMIT(pop_block);
+
+    compile_node(comp, pns->nodes[3]); // else (not tested)
+
+    EMIT(label_assign, break_label);
+    EMIT(label_assign, end_label);
+}
+
+void compile_try_except(compiler_t *comp, py_parse_node_t pn_body, int n_except, py_parse_node_t *pn_excepts, py_parse_node_t pn_else) {
+    // this function is a bit of a hack at the moment
+    // don't understand how the stack works with exceptions, so we force it to return to the correct value
+
+    // setup code
+    int stack_size = EMIT(get_stack_size);
+    int l1 = EMIT(label_new);
+    int success_label = EMIT(label_new);
+    comp->except_nest_level += 1; // for correct handling of continue
+    EMIT(setup_except, l1);
+    compile_node(comp, pn_body); // body
+    EMIT(pop_block);
+    EMIT(jump, success_label);
+    EMIT(label_assign, l1);
+    int l2 = EMIT(label_new);
+
+    for (int i = 0; i < n_except; i++) {
+        assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
+        py_parse_node_struct_t *pns_except = (py_parse_node_struct_t*)pn_excepts[i];
+
+        qstr qstr_exception_local = 0;
+        int end_finally_label = EMIT(label_new);
+
+        if (PY_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
+            // this is a catch all exception handler
+            if (i + 1 != n_except) {
+                printf("SyntaxError: default 'except:' must be last\n");
+                return;
+            }
+        } else {
+            // this exception handler requires a match to a certain type of exception
+            py_parse_node_t pns_exception_expr = pns_except->nodes[0];
+            if (PY_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
+                py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pns_exception_expr;
+                if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
+                    // handler binds the exception to a local
+                    pns_exception_expr = pns3->nodes[0];
+                    qstr_exception_local = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
+                }
+            }
+            EMIT(dup_top);
+            compile_node(comp, pns_exception_expr);
+            EMIT(compare_op, RT_COMPARE_OP_EXCEPTION_MATCH);
+            EMIT(pop_jump_if_false, end_finally_label);
+        }
+
+        EMIT(pop_top);
+
+        if (qstr_exception_local == 0) {
+            EMIT(pop_top);
+        } else {
+            emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, qstr_exception_local);
+        }
+
+        EMIT(pop_top);
+
+        int l3;
+        if (qstr_exception_local != 0) {
+            l3 = EMIT(label_new);
+            EMIT(setup_finally, l3);
+        }
+        compile_node(comp, pns_except->nodes[1]);
+        if (qstr_exception_local != 0) {
+            EMIT(pop_block);
+        }
+        EMIT(pop_except);
+        if (qstr_exception_local != 0) {
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+            EMIT(label_assign, l3);
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+            emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, qstr_exception_local);
+            emit_common_delete_id(comp->pass, comp->scope_cur, comp->emit, qstr_exception_local);
+            EMIT(end_finally);
+        }
+        EMIT(jump, l2);
+        EMIT(label_assign, end_finally_label);
+    }
+
+    EMIT(end_finally);
+    EMIT(label_assign, success_label);
+    comp->except_nest_level -= 1;
+    compile_node(comp, pn_else); // else block, can be null
+    EMIT(label_assign, l2);
+    EMIT(set_stack_size, stack_size);
+}
+
+void compile_try_finally(compiler_t *comp, py_parse_node_t pn_body, int n_except, py_parse_node_t *pn_except, py_parse_node_t pn_else, py_parse_node_t pn_finally) {
+    // don't understand how the stack works with exceptions, so we force it to return to the correct value
+    int stack_size = EMIT(get_stack_size);
+    int l_finally_block = EMIT(label_new);
+    EMIT(setup_finally, l_finally_block);
+    if (n_except == 0) {
+        assert(PY_PARSE_NODE_IS_NULL(pn_else));
+        compile_node(comp, pn_body);
+    } else {
+        compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
+    }
+    EMIT(pop_block);
+    EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+    EMIT(label_assign, l_finally_block);
+    compile_node(comp, pn_finally);
+    EMIT(end_finally);
+    EMIT(set_stack_size, stack_size);
+}
+
+void compile_try_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+        py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
+        if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
+            // just try-finally
+            compile_try_finally(comp, pns->nodes[0], 0, NULL, PY_PARSE_NODE_NULL, pns2->nodes[0]);
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
+            // try-except and possibly else and/or finally
+            py_parse_node_t *pn_excepts;
+            int n_except = list_get(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
+            if (PY_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
+                // no finally
+                compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
+            } else {
+                // have finally
+                compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((py_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
+            }
+        } else {
+            // just try-except
+            py_parse_node_t *pn_excepts;
+            int n_except = list_get(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
+            compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, PY_PARSE_NODE_NULL);
+        }
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+}
+
+void compile_with_stmt_helper(compiler_t *comp, int n, py_parse_node_t *nodes, py_parse_node_t body) {
+    if (n == 0) {
+        // no more pre-bits, compile the body of the with
+        compile_node(comp, body);
+    } else {
+        int l_end = EMIT(label_new);
+        if (PY_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
+            // this pre-bit is of the form "a as b"
+            py_parse_node_struct_t *pns = (py_parse_node_struct_t*)nodes[0];
+            compile_node(comp, pns->nodes[0]);
+            EMIT(setup_with, l_end);
+            c_assign(comp, pns->nodes[1], ASSIGN_STORE);
+        } else {
+            // this pre-bit is just an expression
+            compile_node(comp, nodes[0]);
+            EMIT(setup_with, l_end);
+            EMIT(pop_top);
+        }
+        // compile additional pre-bits and the body
+        compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
+        // finish this with block
+        EMIT(pop_block);
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        EMIT(label_assign, l_end);
+        EMIT(with_cleanup);
+        EMIT(end_finally);
+    }
+}
+
+void compile_with_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
+    py_parse_node_t *nodes;
+    int n = list_get(&pns->nodes[0], PN_with_stmt_list, &nodes);
+    assert(n > 0);
+
+    // compile in a nested fashion
+    compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
+}
+
+void compile_expr_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+        if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+            // do nothing with a lonely constant
+        } else {
+            compile_node(comp, pns->nodes[0]); // just an expression
+            EMIT(pop_top); // discard last result since this is a statement and leaves nothing on the stack
+        }
+    } else {
+        py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
+        int kind = PY_PARSE_NODE_STRUCT_KIND(pns1);
+        if (kind == PN_expr_stmt_augassign) {
+            c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
+            compile_node(comp, pns1->nodes[1]); // rhs
+            assert(PY_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
+            // note that we don't really need to implement separate inplace ops, just normal binary ops will suffice
+            switch (PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
+                case PY_TOKEN_DEL_PIPE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_OR); break;
+                case PY_TOKEN_DEL_CARET_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_XOR); break;
+                case PY_TOKEN_DEL_AMPERSAND_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_AND); break;
+                case PY_TOKEN_DEL_DBL_LESS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_LSHIFT); break;
+                case PY_TOKEN_DEL_DBL_MORE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_RSHIFT); break;
+                case PY_TOKEN_DEL_PLUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_ADD); break;
+                case PY_TOKEN_DEL_MINUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_SUBTRACT); break;
+                case PY_TOKEN_DEL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MULTIPLY); break;
+                case PY_TOKEN_DEL_DBL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_FLOOR_DIVIDE); break;
+                case PY_TOKEN_DEL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_TRUE_DIVIDE); break;
+                case PY_TOKEN_DEL_PERCENT_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MODULO); break;
+                case PY_TOKEN_DEL_DBL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_POWER); break;
+                default: assert(0); // shouldn't happen
+            }
+            c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
+        } else if (kind == PN_expr_stmt_assign_list) {
+            int rhs = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
+            compile_node(comp, ((py_parse_node_struct_t*)pns1->nodes[rhs])->nodes[0]); // rhs
+            // following CPython, we store left-most first
+            if (rhs > 0) {
+                EMIT(dup_top);
+            }
+            c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
+            for (int i = 0; i < rhs; i++) {
+                if (i + 1 < rhs) {
+                    EMIT(dup_top);
+                }
+                c_assign(comp, ((py_parse_node_struct_t*)pns1->nodes[i])->nodes[0], ASSIGN_STORE); // middle store
+            }
+        } else if (kind == PN_expr_stmt_assign) {
+            if (PY_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
+                && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
+                && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns1->nodes[0]) == 2
+                && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns->nodes[0]) == 2) {
+                // optimisation for a, b = c, d; to match CPython's optimisation
+                py_parse_node_struct_t* pns10 = (py_parse_node_struct_t*)pns1->nodes[0];
+                py_parse_node_struct_t* pns0 = (py_parse_node_struct_t*)pns->nodes[0];
+                compile_node(comp, pns10->nodes[0]); // rhs
+                compile_node(comp, pns10->nodes[1]); // rhs
+                EMIT(rot_two);
+                c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
+                c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
+            } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
+                && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
+                && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns1->nodes[0]) == 3
+                && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns->nodes[0]) == 3) {
+                // optimisation for a, b, c = d, e, f; to match CPython's optimisation
+                py_parse_node_struct_t* pns10 = (py_parse_node_struct_t*)pns1->nodes[0];
+                py_parse_node_struct_t* pns0 = (py_parse_node_struct_t*)pns->nodes[0];
+                compile_node(comp, pns10->nodes[0]); // rhs
+                compile_node(comp, pns10->nodes[1]); // rhs
+                compile_node(comp, pns10->nodes[2]); // rhs
+                EMIT(rot_three);
+                EMIT(rot_two);
+                c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
+                c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
+                c_assign(comp, pns0->nodes[2], ASSIGN_STORE); // lhs store
+            } else {
+                compile_node(comp, pns1->nodes[0]); // rhs
+                c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
+            }
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    }
+}
+
+void c_binary_op(compiler_t *comp, py_parse_node_struct_t *pns, rt_binary_op_t binary_op) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    compile_node(comp, pns->nodes[0]);
+    for (int i = 1; i < num_nodes; i += 1) {
+        compile_node(comp, pns->nodes[i]);
+        EMIT(binary_op, binary_op);
+    }
+}
+
+void compile_test_if_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
+    py_parse_node_struct_t *pns_test_if_else = (py_parse_node_struct_t*)pns->nodes[1];
+
+    int stack_size = EMIT(get_stack_size);
+    int l_fail = EMIT(label_new);
+    int l_end = EMIT(label_new);
+    c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
+    compile_node(comp, pns->nodes[0]); // success value
+    EMIT(jump, l_end);
+    EMIT(label_assign, l_fail);
+    EMIT(set_stack_size, stack_size); // force stack size reset
+    compile_node(comp, pns_test_if_else->nodes[1]); // failure value
+    EMIT(label_assign, l_end);
+}
+
+void compile_lambdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // TODO default params etc for lambda; possibly just use funcdef code
+    //py_parse_node_t pn_params = pns->nodes[0];
+    //py_parse_node_t pn_body = pns->nodes[1];
+
+    if (comp->pass == PASS_1) {
+        // create a new scope for this lambda
+        scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (py_parse_node_t)pns);
+        // store the lambda scope so the compiling function (this one) can use it at each pass
+        pns->nodes[2] = (py_parse_node_t)s;
+    }
+
+    // get the scope for this lambda
+    scope_t *this_scope = (scope_t*)pns->nodes[2];
+
+    // make the lambda
+    close_over_variables_etc(comp, this_scope, 0, 0);
+}
+
+void compile_or_test(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int l_end = EMIT(label_new);
+    int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < n; i += 1) {
+        compile_node(comp, pns->nodes[i]);
+        if (i + 1 < n) {
+            EMIT(jump_if_true_or_pop, l_end);
+        }
+    }
+    EMIT(label_assign, l_end);
+}
+
+void compile_and_test(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int l_end = EMIT(label_new);
+    int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < n; i += 1) {
+        compile_node(comp, pns->nodes[i]);
+        if (i + 1 < n) {
+            EMIT(jump_if_false_or_pop, l_end);
+        }
+    }
+    EMIT(label_assign, l_end);
+}
+
+void compile_not_test_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_node(comp, pns->nodes[0]);
+    EMIT(unary_op, RT_UNARY_OP_NOT);
+}
+
+void compile_comparison(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int stack_size = EMIT(get_stack_size);
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    compile_node(comp, pns->nodes[0]);
+    bool multi = (num_nodes > 3);
+    int l_fail = 0;
+    if (multi) {
+        l_fail = EMIT(label_new);
+    }
+    for (int i = 1; i + 1 < num_nodes; i += 2) {
+        compile_node(comp, pns->nodes[i + 1]);
+        if (i + 2 < num_nodes) {
+            EMIT(dup_top);
+            EMIT(rot_three);
+        }
+        if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_LESS)) {
+            EMIT(compare_op, RT_COMPARE_OP_LESS);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MORE)) {
+            EMIT(compare_op, RT_COMPARE_OP_MORE);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_EQUAL)) {
+            EMIT(compare_op, RT_COMPARE_OP_EQUAL);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_LESS_EQUAL)) {
+            EMIT(compare_op, RT_COMPARE_OP_LESS_EQUAL);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MORE_EQUAL)) {
+            EMIT(compare_op, RT_COMPARE_OP_MORE_EQUAL);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_NOT_EQUAL)) {
+            EMIT(compare_op, RT_COMPARE_OP_NOT_EQUAL);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_KW_IN)) {
+            EMIT(compare_op, RT_COMPARE_OP_IN);
+        } else if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[i])) {
+            py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[i];
+            int kind = PY_PARSE_NODE_STRUCT_KIND(pns2);
+            if (kind == PN_comp_op_not_in) {
+                EMIT(compare_op, RT_COMPARE_OP_NOT_IN);
+            } else if (kind == PN_comp_op_is) {
+                if (PY_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
+                    EMIT(compare_op, RT_COMPARE_OP_IS);
+                } else {
+                    EMIT(compare_op, RT_COMPARE_OP_IS_NOT);
+                }
+            } else {
+                // shouldn't happen
+                assert(0);
+            }
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+        if (i + 2 < num_nodes) {
+            EMIT(jump_if_false_or_pop, l_fail);
+        }
+    }
+    if (multi) {
+        int l_end = EMIT(label_new);
+        EMIT(jump, l_end);
+        EMIT(label_assign, l_fail);
+        EMIT(rot_two);
+        EMIT(pop_top);
+        EMIT(label_assign, l_end);
+        EMIT(set_stack_size, stack_size + 1); // force stack size
+    }
+}
+
+void compile_star_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // TODO
+    assert(0);
+    compile_node(comp, pns->nodes[0]);
+    //EMIT(unary_op, "UNARY_STAR");
+}
+
+void compile_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    c_binary_op(comp, pns, RT_BINARY_OP_OR);
+}
+
+void compile_xor_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    c_binary_op(comp, pns, RT_BINARY_OP_XOR);
+}
+
+void compile_and_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    c_binary_op(comp, pns, RT_BINARY_OP_AND);
+}
+
+void compile_shift_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    compile_node(comp, pns->nodes[0]);
+    for (int i = 1; i + 1 < num_nodes; i += 2) {
+        compile_node(comp, pns->nodes[i + 1]);
+        if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_LESS)) {
+            EMIT(binary_op, RT_BINARY_OP_LSHIFT);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_MORE)) {
+            EMIT(binary_op, RT_BINARY_OP_RSHIFT);
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    }
+}
+
+void compile_arith_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    compile_node(comp, pns->nodes[0]);
+    for (int i = 1; i + 1 < num_nodes; i += 2) {
+        compile_node(comp, pns->nodes[i + 1]);
+        if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_PLUS)) {
+            EMIT(binary_op, RT_BINARY_OP_ADD);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MINUS)) {
+            EMIT(binary_op, RT_BINARY_OP_SUBTRACT);
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    }
+}
+
+void compile_term(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    compile_node(comp, pns->nodes[0]);
+    for (int i = 1; i + 1 < num_nodes; i += 2) {
+        compile_node(comp, pns->nodes[i + 1]);
+        if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_STAR)) {
+            EMIT(binary_op, RT_BINARY_OP_MULTIPLY);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_SLASH)) {
+            EMIT(binary_op, RT_BINARY_OP_FLOOR_DIVIDE);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_SLASH)) {
+            EMIT(binary_op, RT_BINARY_OP_TRUE_DIVIDE);
+        } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_PERCENT)) {
+            EMIT(binary_op, RT_BINARY_OP_MODULO);
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    }
+}
+
+void compile_factor_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_node(comp, pns->nodes[1]);
+    if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_PLUS)) {
+        EMIT(unary_op, RT_UNARY_OP_POSITIVE);
+    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_MINUS)) {
+        EMIT(unary_op, RT_UNARY_OP_NEGATIVE);
+    } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_TILDE)) {
+        EMIT(unary_op, RT_UNARY_OP_INVERT);
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+}
+
+void compile_trailer_paren_helper(compiler_t *comp, py_parse_node_struct_t *pns, bool is_method_call) {
+    // function to call is on top of stack
+
+    int old_n_arg_keyword = comp->n_arg_keyword;
+    bool old_have_star_arg = comp->have_star_arg;
+    bool old_have_dbl_star_arg = comp->have_dbl_star_arg;
+    comp->n_arg_keyword = 0;
+    comp->have_star_arg = false;
+    comp->have_dbl_star_arg = false;
+
+    compile_node(comp, pns->nodes[0]); // arguments to function call; can be null
+
+    // compute number of positional arguments
+    int n_positional = list_len(pns->nodes[0], PN_arglist) - comp->n_arg_keyword;
+    if (comp->have_star_arg) {
+        n_positional -= 1;
+    }
+    if (comp->have_dbl_star_arg) {
+        n_positional -= 1;
+    }
+
+    if (is_method_call) {
+        EMIT(call_method, n_positional, comp->n_arg_keyword, comp->have_star_arg, comp->have_dbl_star_arg);
+    } else {
+        EMIT(call_function, n_positional, comp->n_arg_keyword, comp->have_star_arg, comp->have_dbl_star_arg);
+    }
+
+    comp->n_arg_keyword = old_n_arg_keyword;
+    comp->have_star_arg = old_have_star_arg;
+    comp->have_dbl_star_arg = old_have_dbl_star_arg;
+}
+
+void compile_power_trailers(compiler_t *comp, py_parse_node_struct_t *pns) {
+    int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < num_nodes; i++) {
+        if (i + 1 < num_nodes && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i], PN_trailer_period) && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i + 1], PN_trailer_paren)) {
+            // optimisation for method calls a.f(...), following PyPy
+            py_parse_node_struct_t *pns_period = (py_parse_node_struct_t*)pns->nodes[i];
+            py_parse_node_struct_t *pns_paren = (py_parse_node_struct_t*)pns->nodes[i + 1];
+            EMIT(load_method, PY_PARSE_NODE_LEAF_ARG(pns_period->nodes[0])); // get the method
+            compile_trailer_paren_helper(comp, pns_paren, true);
+            i += 1;
+        } else {
+            compile_node(comp, pns->nodes[i]);
+        }
+    }
+}
+
+void compile_power_dbl_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_node(comp, pns->nodes[0]);
+    EMIT(binary_op, RT_BINARY_OP_POWER);
+}
+
+void compile_atom_string(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // a list of strings
+    EMIT(load_const_verbatim_start);
+    EMIT(load_const_verbatim_str, "'");
+    int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+    for (int i = 0; i < n; i++) {
+        // TODO allow concatenation of either strings or bytes, but not mixed
+        assert(PY_PARSE_NODE_IS_LEAF(pns->nodes[i]));
+        assert(PY_PARSE_NODE_LEAF_KIND(pns->nodes[i]) == PY_PARSE_NODE_STRING);
+        const char *str = qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+        EMIT(load_const_verbatim_strn, str, strlen(str));
+    }
+    EMIT(load_const_verbatim_str, "'");
+    EMIT(load_const_verbatim_end);
+}
+
+// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
+void compile_comprehension(compiler_t *comp, py_parse_node_struct_t *pns, scope_kind_t kind) {
+    assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
+    assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
+    py_parse_node_struct_t *pns_comp_for = (py_parse_node_struct_t*)pns->nodes[1];
+
+    if (comp->pass == PASS_1) {
+        // create a new scope for this comprehension
+        scope_t *s = scope_new_and_link(comp, kind, (py_parse_node_t)pns);
+        // store the comprehension scope so the compiling function (this one) can use it at each pass
+        pns_comp_for->nodes[3] = (py_parse_node_t)s;
+    }
+
+    // get the scope for this comprehension
+    scope_t *this_scope = (scope_t*)pns_comp_for->nodes[3];
+
+    // compile the comprehension
+    close_over_variables_etc(comp, this_scope, 0, 0);
+
+    compile_node(comp, pns_comp_for->nodes[1]); // source of the iterator
+    EMIT(get_iter);
+    EMIT(call_function, 1, 0, false, false);
+}
+
+void compile_atom_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+        // an empty tuple
+        /*
+        EMIT(build_tuple, 0);
+        */
+        c_tuple(comp, PY_PARSE_NODE_NULL, NULL);
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+        pns = (py_parse_node_struct_t*)pns->nodes[0];
+        assert(!PY_PARSE_NODE_IS_NULL(pns->nodes[1]));
+        if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+            py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
+            if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
+                // tuple of one item, with trailing comma
+                assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[0]));
+                /*
+                compile_node(comp, pns->nodes[0]);
+                EMIT(build_tuple, 1);
+                */
+                c_tuple(comp, pns->nodes[0], NULL);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
+                // tuple of many items
+                /*
+                compile_node(comp, pns->nodes[0]);
+                compile_generic_all_nodes(comp, pns2);
+                EMIT(build_tuple, 1 + PY_PARSE_NODE_STRUCT_NUM_NODES(pns2));
+                */
+                c_tuple(comp, pns->nodes[0], pns2);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
+                // generator expression
+                compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
+            } else {
+                // tuple with 2 items
+                goto tuple_with_2_items;
+            }
+        } else {
+            // tuple with 2 items
+            tuple_with_2_items:
+            /*
+            compile_node(comp, pns->nodes[0]);
+            compile_node(comp, pns->nodes[1]);
+            EMIT(build_tuple, 2);
+            */
+            c_tuple(comp, PY_PARSE_NODE_NULL, pns);
+        }
+    } else {
+        // parenthesis around a single item, is just that item
+        compile_node(comp, pns->nodes[0]);
+    }
+}
+
+void compile_atom_bracket(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+        // empty list
+        EMIT(build_list, 0);
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+        py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[0];
+        if (PY_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
+            py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pns2->nodes[1];
+            if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
+                // list of one item, with trailing comma
+                assert(PY_PARSE_NODE_IS_NULL(pns3->nodes[0]));
+                compile_node(comp, pns2->nodes[0]);
+                EMIT(build_list, 1);
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
+                // list of many items
+                compile_node(comp, pns2->nodes[0]);
+                compile_generic_all_nodes(comp, pns3);
+                EMIT(build_list, 1 + PY_PARSE_NODE_STRUCT_NUM_NODES(pns3));
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
+                // list comprehension
+                compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
+            } else {
+                // list with 2 items
+                goto list_with_2_items;
+            }
+        } else {
+            // list with 2 items
+            list_with_2_items:
+            compile_node(comp, pns2->nodes[0]);
+            compile_node(comp, pns2->nodes[1]);
+            EMIT(build_list, 2);
+        }
+    } else {
+        // list with 1 item
+        compile_node(comp, pns->nodes[0]);
+        EMIT(build_list, 1);
+    }
+}
+
+void compile_atom_brace(compiler_t *comp, py_parse_node_struct_t *pns) {
+    py_parse_node_t pn = pns->nodes[0];
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        // empty dict
+        EMIT(build_map, 0);
+    } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
+        pns = (py_parse_node_struct_t*)pn;
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
+            // dict with one element
+            EMIT(build_map, 1);
+            compile_node(comp, pn);
+            EMIT(store_map);
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
+            assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
+            py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
+            if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
+                // dict/set with multiple elements
+
+                // get tail elements (2nd, 3rd, ...)
+                py_parse_node_t *nodes;
+                int n = list_get(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
+
+                // first element sets whether it's a dict or set
+                bool is_dict;
+                if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
+                    // a dictionary
+                    EMIT(build_map, 1 + n);
+                    compile_node(comp, pns->nodes[0]);
+                    EMIT(store_map);
+                    is_dict = true;
+                } else {
+                    // a set
+                    compile_node(comp, pns->nodes[0]); // 1st value of set
+                    is_dict = false;
+                }
+
+                // process rest of elements
+                for (int i = 0; i < n; i++) {
+                    py_parse_node_t pn = nodes[i];
+                    bool is_key_value = PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dictorsetmaker_item);
+                    compile_node(comp, pn);
+                    if (is_dict) {
+                        if (!is_key_value) {
+                            printf("SyntaxError?: expecting key:value for dictionary");
+                            return;
+                        }
+                        EMIT(store_map);
+                    } else {
+                        if (is_key_value) {
+                            printf("SyntaxError?: expecting just a value for set");
+                            return;
+                        }
+                    }
+                }
+
+                // if it's a set, build it
+                if (!is_dict) {
+                    EMIT(build_set, 1 + n);
+                }
+            } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
+                // dict/set comprehension
+                if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
+                    // a dictionary comprehension
+                    compile_comprehension(comp, pns, SCOPE_DICT_COMP);
+                } else {
+                    // a set comprehension
+                    compile_comprehension(comp, pns, SCOPE_SET_COMP);
+                }
+            } else {
+                // shouldn't happen
+                assert(0);
+            }
+        } else {
+            // set with one element
+            goto set_with_one_element;
+        }
+    } else {
+        // set with one element
+        set_with_one_element:
+        compile_node(comp, pn);
+        EMIT(build_set, 1);
+    }
+}
+
+void compile_trailer_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_trailer_paren_helper(comp, pns, false);
+}
+
+void compile_trailer_bracket(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // object who's index we want is on top of stack
+    compile_node(comp, pns->nodes[0]); // the index
+    EMIT(binary_op, RT_BINARY_OP_SUBSCR);
+}
+
+void compile_trailer_period(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // object who's attribute we want is on top of stack
+    EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // attribute to get
+}
+
+void compile_subscript_3_helper(compiler_t *comp, py_parse_node_struct_t *pns) {
+    assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
+    py_parse_node_t pn = pns->nodes[0];
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        // [?:]
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        EMIT(build_slice, 2);
+    } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
+        pns = (py_parse_node_struct_t*)pn;
+        if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+            pn = pns->nodes[0];
+            if (PY_PARSE_NODE_IS_NULL(pn)) {
+                // [?::]
+                EMIT(build_slice, 2);
+            } else {
+                // [?::x]
+                compile_node(comp, pn);
+                EMIT(build_slice, 3);
+            }
+        } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
+            compile_node(comp, pns->nodes[0]);
+            assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+            pns = (py_parse_node_struct_t*)pns->nodes[1];
+            assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
+            if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+                // [?:x:]
+                EMIT(build_slice, 2);
+            } else {
+                // [?:x:x]
+                compile_node(comp, pns->nodes[0]);
+                EMIT(build_slice, 3);
+            }
+        } else {
+            // [?:x]
+            compile_node(comp, pn);
+            EMIT(build_slice, 2);
+        }
+    } else {
+        // [?:x]
+        compile_node(comp, pn);
+        EMIT(build_slice, 2);
+    }
+}
+
+void compile_subscript_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+    compile_node(comp, pns->nodes[0]); // start of slice
+    assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+    compile_subscript_3_helper(comp, (py_parse_node_struct_t*)pns->nodes[1]);
+}
+
+void compile_subscript_3(compiler_t *comp, py_parse_node_struct_t *pns) {
+    EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+    compile_subscript_3_helper(comp, pns);
+}
+
+void compile_dictorsetmaker_item(compiler_t *comp, py_parse_node_struct_t *pns) {
+    // if this is called then we are compiling a dict key:value pair
+    compile_node(comp, pns->nodes[1]); // value
+    compile_node(comp, pns->nodes[0]); // key
+}
+
+void compile_classdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+    qstr cname = compile_classdef_helper(comp, pns);
+    // store class object into class name
+    emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, cname);
+}
+
+void compile_arglist_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->have_star_arg) {
+        printf("SyntaxError?: can't have multiple *x\n");
+        return;
+    }
+    comp->have_star_arg = true;
+    compile_node(comp, pns->nodes[0]);
+}
+
+void compile_arglist_dbl_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->have_dbl_star_arg) {
+        printf("SyntaxError?: can't have multiple **x\n");
+        return;
+    }
+    comp->have_dbl_star_arg = true;
+    compile_node(comp, pns->nodes[0]);
+}
+
+void compile_argument(compiler_t *comp, py_parse_node_struct_t *pns) {
+    assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+    py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
+    if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_argument_3) {
+        if (!PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+            printf("SyntaxError?: lhs of keyword argument must be an id\n");
+            return;
+        }
+        EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+        compile_node(comp, pns2->nodes[0]);
+        comp->n_arg_keyword += 1;
+    } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
+        compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+}
+
+void compile_yield_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+    if (comp->scope_cur->kind != SCOPE_FUNCTION) {
+        printf("SyntaxError: 'yield' outside function\n");
+        return;
+    }
+    if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        EMIT(yield_value);
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
+        pns = (py_parse_node_struct_t*)pns->nodes[0];
+        compile_node(comp, pns->nodes[0]);
+        EMIT(get_iter);
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        EMIT(yield_from);
+    } else {
+        compile_node(comp, pns->nodes[0]);
+        EMIT(yield_value);
+    }
+}
+
+typedef void (*compile_function_t)(compiler_t*, py_parse_node_struct_t*);
+static compile_function_t compile_function[] = {
+    NULL,
+#define nc NULL
+#define c(f) compile_##f
+#define DEF_RULE(rule, comp, kind, arg...) comp,
+#include "grammar.h"
+#undef nc
+#undef c
+#undef DEF_RULE
+};
+
+void compile_node(compiler_t *comp, py_parse_node_t pn) {
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        // pass
+    } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
+        int arg = PY_PARSE_NODE_LEAF_ARG(pn);
+        switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
+            case PY_PARSE_NODE_ID: emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, arg); break;
+            case PY_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break;
+            case PY_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break;
+            case PY_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break;
+            case PY_PARSE_NODE_STRING: EMIT(load_const_str, arg, false); break;
+            case PY_PARSE_NODE_BYTES: EMIT(load_const_str, arg, true); break;
+            case PY_PARSE_NODE_TOKEN: EMIT(load_const_tok, arg); break;
+            default: assert(0);
+        }
+    } else {
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+        compile_function_t f = compile_function[PY_PARSE_NODE_STRUCT_KIND(pns)];
+        if (f == NULL) {
+            printf("node %u cannot be compiled\n", (uint)PY_PARSE_NODE_STRUCT_KIND(pns));
+            parse_node_show(pn, 0);
+            assert(0);
+        } else {
+            f(comp, pns);
+        }
+    }
+}
+
+void compile_scope_func_lambda_param(compiler_t *comp, py_parse_node_t pn, pn_kind_t pn_name, pn_kind_t pn_star, pn_kind_t pn_dbl_star, bool allow_annotations) {
+    // TODO verify that *k and **k are last etc
+    assert(PY_PARSE_NODE_IS_STRUCT(pn));
+    py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+    qstr param_name = 0;
+    py_parse_node_t pn_annotation = PY_PARSE_NODE_NULL;
+    if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
+        param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+        //int node_index = 1; unused
+        if (allow_annotations) {
+            if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+                // this parameter has an annotation
+                pn_annotation = pns->nodes[1];
+            }
+            //node_index = 2; unused
+        }
+        /* this is obsolete now that num dict/default params are calculated in compile_funcdef_param
+        if (!PY_PARSE_NODE_IS_NULL(pns->nodes[node_index])) {
+            // this parameter has a default value
+            if (comp->have_bare_star) {
+                comp->scope_cur->num_dict_params += 1;
+            } else {
+                comp->scope_cur->num_default_params += 1;
+            }
+        }
+        */
+        if (comp->have_bare_star) {
+            // comes after a bare star, so doesn't count as a parameter
+        } else {
+            comp->scope_cur->num_params += 1;
+        }
+    } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
+        if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+            // bare star
+            // TODO see http://www.python.org/dev/peps/pep-3102/
+            comp->have_bare_star = true;
+            //assert(comp->scope_cur->num_dict_params == 0);
+        } else if (PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+            // named star
+            comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
+            param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+        } else if (allow_annotations && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)) {
+            // named star with annotation
+            comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
+            pns = (py_parse_node_struct_t*)pns->nodes[0];
+            param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+            pn_annotation = pns->nodes[1];
+        } else {
+            // shouldn't happen
+            assert(0);
+        }
+    } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star) {
+        param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+        if (allow_annotations && !PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+            // this parameter has an annotation
+            pn_annotation = pns->nodes[1];
+        }
+        comp->scope_cur->flags |= SCOPE_FLAG_VARKEYWORDS;
+    } else {
+        // TODO anything to implement?
+        assert(0);
+    }
+
+    if (param_name != 0) {
+        if (!PY_PARSE_NODE_IS_NULL(pn_annotation)) {
+            // TODO this parameter has an annotation
+        }
+        bool added;
+        id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, &added);
+        if (!added) {
+            printf("SyntaxError?: same name used for parameter; %s\n", qstr_str(param_name));
+            return;
+        }
+        id_info->param = true;
+        id_info->kind = ID_INFO_KIND_LOCAL;
+    }
+}
+
+void compile_scope_func_param(compiler_t *comp, py_parse_node_t pn) {
+    compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star, true);
+}
+
+void compile_scope_lambda_param(compiler_t *comp, py_parse_node_t pn) {
+    compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star, false);
+}
+
+void compile_scope_comp_iter(compiler_t *comp, py_parse_node_t pn_iter, py_parse_node_t pn_inner_expr, int l_top, int for_depth) {
+    tail_recursion:
+    if (PY_PARSE_NODE_IS_NULL(pn_iter)) {
+        // no more nested if/for; compile inner expression
+        compile_node(comp, pn_inner_expr);
+        if (comp->scope_cur->kind == SCOPE_LIST_COMP) {
+            EMIT(list_append, for_depth + 2);
+        } else if (comp->scope_cur->kind == SCOPE_DICT_COMP) {
+            EMIT(map_add, for_depth + 2);
+        } else if (comp->scope_cur->kind == SCOPE_SET_COMP) {
+            EMIT(set_add, for_depth + 2);
+        } else {
+            EMIT(yield_value);
+            EMIT(pop_top);
+        }
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_if)) {
+        // if condition
+        py_parse_node_struct_t *pns_comp_if = (py_parse_node_struct_t*)pn_iter;
+        c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
+        pn_iter = pns_comp_if->nodes[1];
+        goto tail_recursion;
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_for)) {
+        // for loop
+        py_parse_node_struct_t *pns_comp_for2 = (py_parse_node_struct_t*)pn_iter;
+        compile_node(comp, pns_comp_for2->nodes[1]);
+        int l_end2 = EMIT(label_new);
+        int l_top2 = EMIT(label_new);
+        EMIT(get_iter);
+        EMIT(label_assign, l_top2);
+        EMIT(for_iter, l_end2);
+        c_assign(comp, pns_comp_for2->nodes[0], ASSIGN_STORE);
+        compile_scope_comp_iter(comp, pns_comp_for2->nodes[2], pn_inner_expr, l_top2, for_depth + 1);
+        EMIT(jump, l_top2);
+        EMIT(label_assign, l_end2);
+        EMIT(for_iter_end);
+    } else {
+        // shouldn't happen
+        assert(0);
+    }
+}
+
+void check_for_doc_string(compiler_t *comp, py_parse_node_t pn) {
+    // see http://www.python.org/dev/peps/pep-0257/
+
+    // look for the first statement
+    if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
+        // fall through
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
+        pn = ((py_parse_node_struct_t*)pn)->nodes[0];
+    } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
+        pn = ((py_parse_node_struct_t*)pn)->nodes[0];
+    } else {
+        return;
+    }
+
+    // check the first statement for a doc string
+    if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
+        py_parse_node_struct_t* pns = (py_parse_node_struct_t*)pn;
+        if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+            int kind = PY_PARSE_NODE_LEAF_KIND(pns->nodes[0]);
+            if (kind == PY_PARSE_NODE_STRING) {
+                compile_node(comp, pns->nodes[0]); // a doc string
+                // store doc string
+                emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, comp->qstr___doc__);
+            }
+        }
+    }
+}
+
+void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
+    comp->pass = pass;
+    comp->scope_cur = scope;
+    emit_start_pass(comp->emit, pass, scope);
+
+    if (comp->pass == PASS_1) {
+        scope->stack_size = 0;
+    }
+
+    if (comp->pass == PASS_3) {
+        //printf("----\n");
+        scope_print_info(scope);
+    }
+
+    // compile
+    if (scope->kind == SCOPE_MODULE) {
+        check_for_doc_string(comp, scope->pn);
+        compile_node(comp, scope->pn);
+        EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        EMIT(return_value);
+    } else if (scope->kind == SCOPE_FUNCTION) {
+        assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
+        assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
+
+        // work out number of parameters, keywords and default parameters, and add them to the id_info array
+        if (comp->pass == PASS_1) {
+            comp->have_bare_star = false;
+            apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
+        }
+
+        assert(pns->nodes[2] == 0); // 2 is something...
+
+        compile_node(comp, pns->nodes[3]); // 3 is function body
+        // emit return if it wasn't the last opcode
+        if (!emit_last_emit_was_return_value(comp->emit)) {
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+            EMIT(return_value);
+        }
+    } else if (scope->kind == SCOPE_LAMBDA) {
+        assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
+        assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
+
+        // work out number of parameters, keywords and default parameters, and add them to the id_info array
+        if (comp->pass == PASS_1) {
+            comp->have_bare_star = false;
+            apply_to_single_or_list(comp, pns->nodes[0], PN_varargslist, compile_scope_lambda_param);
+        }
+
+        compile_node(comp, pns->nodes[1]); // 1 is lambda body
+        EMIT(return_value);
+    } else if (scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
+        // a bit of a hack at the moment
+
+        assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
+        assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
+        assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
+        py_parse_node_struct_t *pns_comp_for = (py_parse_node_struct_t*)pns->nodes[1];
+
+        qstr qstr_arg = qstr_from_strn_copy(".0", 2);
+        if (comp->pass == PASS_1) {
+            bool added;
+            id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qstr_arg, &added);
+            assert(added);
+            id_info->kind = ID_INFO_KIND_LOCAL;
+            scope->num_params = 1;
+        }
+
+        if (scope->kind == SCOPE_LIST_COMP) {
+            EMIT(build_list, 0);
+        } else if (scope->kind == SCOPE_DICT_COMP) {
+            EMIT(build_map, 0);
+        } else if (scope->kind == SCOPE_SET_COMP) {
+            EMIT(build_set, 0);
+        }
+
+        int l_end = EMIT(label_new);
+        int l_top = EMIT(label_new);
+        emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, qstr_arg);
+        EMIT(label_assign, l_top);
+        EMIT(for_iter, l_end);
+        c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
+        compile_scope_comp_iter(comp, pns_comp_for->nodes[2], pns->nodes[0], l_top, 0);
+        EMIT(jump, l_top);
+        EMIT(label_assign, l_end);
+        EMIT(for_iter_end);
+
+        if (scope->kind == SCOPE_GEN_EXPR) {
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        }
+        EMIT(return_value);
+    } else {
+        assert(scope->kind == SCOPE_CLASS);
+        assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
+        py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
+        assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
+
+        if (comp->pass == PASS_1) {
+            bool added;
+            id_info_t *id_info = scope_find_or_add_id(scope, comp->qstr___class__, &added);
+            assert(added);
+            id_info->kind = ID_INFO_KIND_LOCAL;
+            id_info = scope_find_or_add_id(scope, comp->qstr___locals__, &added);
+            assert(added);
+            id_info->kind = ID_INFO_KIND_LOCAL;
+            id_info->param = true;
+            scope->num_params = 1; // __locals__ is the parameter
+        }
+
+        emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, comp->qstr___locals__);
+        EMIT(store_locals);
+        emit_common_load_id(comp->pass, comp->scope_cur, comp->qstr___class__, comp->emit, comp->qstr___name__);
+        emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, comp->qstr___module__);
+        EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
+        emit_common_store_id(comp->pass, comp->scope_cur, comp->emit, comp->qstr___qualname__);
+
+        check_for_doc_string(comp, pns->nodes[2]);
+        compile_node(comp, pns->nodes[2]); // 2 is class body
+
+        id_info_t *id = scope_find(scope, comp->qstr___class__);
+        assert(id != NULL);
+        if (id->kind == ID_INFO_KIND_LOCAL) {
+            EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+        } else {
+            EMIT(load_closure, comp->qstr___class__);
+        }
+        EMIT(return_value);
+    }
+
+    emit_end_pass(comp->emit);
+}
+
+void compile_scope_compute_things(compiler_t *comp, scope_t *scope) {
+    // in functions, turn implicit globals into explicit globals
+    // compute num_locals, and the index of each local
+    scope->num_locals = 0;
+    for (int i = 0; i < scope->id_info_len; i++) {
+        id_info_t *id = &scope->id_info[i];
+        if (scope->kind == SCOPE_CLASS && id->qstr == comp->qstr___class__) {
+            // __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL
+            continue;
+        }
+        if (scope->kind >= SCOPE_FUNCTION && scope->kind <= SCOPE_GEN_EXPR && id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+            id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
+        }
+        if (id->param || id->kind == ID_INFO_KIND_LOCAL) {
+            id->local_num = scope->num_locals;
+            scope->num_locals += 1;
+        }
+    }
+
+    // compute flags
+    //scope->flags = 0; since we set some things in parameters
+    if (scope->kind != SCOPE_MODULE) {
+        scope->flags |= SCOPE_FLAG_NEWLOCALS;
+    }
+    if (scope->kind == SCOPE_FUNCTION || scope->kind == SCOPE_LAMBDA || scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
+        assert(scope->parent != NULL);
+        scope->flags |= SCOPE_FLAG_OPTIMISED;
+
+        // TODO possibly other ways it can be nested
+        if (scope->parent->kind == SCOPE_FUNCTION || (scope->parent->kind == SCOPE_CLASS && scope->parent->parent->kind == SCOPE_FUNCTION)) {
+            scope->flags |= SCOPE_FLAG_NESTED;
+        }
+    }
+    int num_free = 0;
+    for (int i = 0; i < scope->id_info_len; i++) {
+        id_info_t *id = &scope->id_info[i];
+        if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
+            num_free += 1;
+        }
+    }
+    if (num_free == 0) {
+        scope->flags |= SCOPE_FLAG_NOFREE;
+    }
+}
+
+void py_compile(py_parse_node_t pn) {
+    compiler_t *comp = m_new(compiler_t, 1);
+
+    comp->qstr___class__ = qstr_from_strn_copy("__class__", 9);
+    comp->qstr___locals__ = qstr_from_strn_copy("__locals__", 10);
+    comp->qstr___name__ = qstr_from_strn_copy("__name__", 8);
+    comp->qstr___module__ = qstr_from_strn_copy("__module__", 10);
+    comp->qstr___qualname__ = qstr_from_strn_copy("__qualname__", 12);
+    comp->qstr___doc__ = qstr_from_strn_copy("__doc__", 7);
+    comp->qstr_assertion_error = qstr_from_strn_copy("AssertionError", 14);
+
+    comp->break_label = 0;
+    comp->continue_label = 0;
+    comp->except_nest_level = 0;
+    comp->scope_head = NULL;
+    comp->scope_cur = NULL;
+
+    comp->emit = emit_new(comp->qstr___class__);
+
+    pn = fold_constants(pn);
+    scope_new_and_link(comp, SCOPE_MODULE, pn);
+
+    for (scope_t *s = comp->scope_head; s != NULL; s = s->next) {
+        compile_scope(comp, s, PASS_1);
+    }
+
+    for (scope_t *s = comp->scope_head; s != NULL; s = s->next) {
+        compile_scope_compute_things(comp, s);
+    }
+
+    for (scope_t *s = comp->scope_head; s != NULL; s = s->next) {
+        compile_scope(comp, s, PASS_2);
+        compile_scope(comp, s, PASS_3);
+    }
+
+    m_free(comp);
+}
diff --git a/py/compile.h b/py/compile.h
new file mode 100644
index 0000000..339acca
--- /dev/null
+++ b/py/compile.h
@@ -0,0 +1 @@
+void py_compile(py_parse_node_t pn);
diff --git a/py/emit.h b/py/emit.h
new file mode 100644
index 0000000..8cad745
--- /dev/null
+++ b/py/emit.h
@@ -0,0 +1,120 @@
+//#define EMIT_DO_CPY
+#define EMIT_DO_BC
+//#define EMIT_DO_X64
+//#define EMIT_DO_THUMB
+
+/* Notes on passes:
+ * We don't know exactly the opcodes in pass 1 because they depend on the
+ * closing over of variables (LOAD_CLOSURE, BUILD_TUPLE, MAKE_CLOSURE), which
+ * depends on determining the scope of variables in each function, and this
+ * is not known until the end of pass 1.
+ * As a consequence, we don't know the maximum stack size until the end of pass 2.
+ * This is problematic for some emitters (x64) since they need to know the maximum
+ * stack size to compile the entry to the function, and this effects code size.
+ */
+
+typedef enum {
+    PASS_1 = 1, // work out id's and their kind, and number of labels
+    PASS_2 = 2, // work out stack size and code size and label offsets
+    PASS_3 = 3, // emit code
+} pass_kind_t;
+
+typedef struct _emitter_t emitter_t;
+
+void emit_common_declare_global(pass_kind_t pass, scope_t *scope, qstr qstr);
+void emit_common_declare_nonlocal(pass_kind_t pass, scope_t *scope, qstr qstr);
+void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__, emitter_t *emit, qstr qstr);
+void emit_common_store_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr);
+void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr);
+
+emitter_t *emit_new();
+void emit_set_native_types(emitter_t *emit, bool do_native_types);
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope);
+void emit_end_pass(emitter_t *emit);
+bool emit_last_emit_was_return_value(emitter_t *emit);
+int emit_get_stack_size(emitter_t *emit);
+void emit_set_stack_size(emitter_t *emit, int size);
+
+int emit_label_new(emitter_t *emit);
+void emit_label_assign(emitter_t *emit, int l);
+void emit_import_name(emitter_t *emit, qstr qstr);
+void emit_import_from(emitter_t *emit, qstr qstr);
+void emit_import_star(emitter_t *emit);
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok);
+void emit_load_const_small_int(emitter_t *emit, int arg);
+void emit_load_const_int(emitter_t *emit, qstr qstr);
+void emit_load_const_dec(emitter_t *emit, qstr qstr);
+void emit_load_const_id(emitter_t *emit, qstr qstr);
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes);
+void emit_load_const_verbatim_start(emitter_t *emit);
+void emit_load_const_verbatim_int(emitter_t *emit, int val);
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str);
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len);
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes);
+void emit_load_const_verbatim_end(emitter_t *emit);
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_load_name(emitter_t *emit, qstr qstr);
+void emit_load_global(emitter_t *emit, qstr qstr);
+void emit_load_deref(emitter_t *emit, qstr qstr);
+void emit_load_closure(emitter_t *emit, qstr qstr);
+void emit_load_attr(emitter_t *emit, qstr qstr);
+void emit_load_method(emitter_t *emit, qstr qstr);
+void emit_load_build_class(emitter_t *emit);
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_store_name(emitter_t *emit, qstr qstr);
+void emit_store_global(emitter_t *emit, qstr qstr);
+void emit_store_deref(emitter_t *emit, qstr qstr);
+void emit_store_attr(emitter_t *emit, qstr qstr);
+void emit_store_locals(emitter_t *emit);
+void emit_store_subscr(emitter_t *emit);
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_delete_name(emitter_t *emit, qstr qstr);
+void emit_delete_global(emitter_t *emit, qstr qstr);
+void emit_delete_deref(emitter_t *emit, qstr qstr);
+void emit_delete_attr(emitter_t *emit, qstr qstr);
+void emit_delete_subscr(emitter_t *emit);
+void emit_dup_top(emitter_t *emit);
+void emit_dup_top_two(emitter_t *emit);
+void emit_pop_top(emitter_t *emit);
+void emit_rot_two(emitter_t *emit);
+void emit_rot_three(emitter_t *emit);
+void emit_jump(emitter_t *emit, int label);
+void emit_pop_jump_if_true(emitter_t *emit, int label);
+void emit_pop_jump_if_false(emitter_t *emit, int label);
+void emit_jump_if_true_or_pop(emitter_t *emit, int label);
+void emit_jump_if_false_or_pop(emitter_t *emit, int label);
+void emit_setup_loop(emitter_t *emit, int label);
+void emit_break_loop(emitter_t *emit, int label);
+void emit_continue_loop(emitter_t *emit, int label);
+void emit_setup_with(emitter_t *emit, int label);
+void emit_with_cleanup(emitter_t *emit);
+void emit_setup_except(emitter_t *emit, int label);
+void emit_setup_finally(emitter_t *emit, int label);
+void emit_end_finally(emitter_t *emit);
+void emit_get_iter(emitter_t *emit); // tos = getiter(tos)
+void emit_for_iter(emitter_t *emit, int label);
+void emit_for_iter_end(emitter_t *emit);
+void emit_pop_block(emitter_t *emit);
+void emit_pop_except(emitter_t *emit);
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op);
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op);
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op);
+void emit_build_tuple(emitter_t *emit, int n_args);
+void emit_build_list(emitter_t *emit, int n_args);
+void emit_list_append(emitter_t *emit, int list_stack_index);
+void emit_build_map(emitter_t *emit, int n_args);
+void emit_store_map(emitter_t *emit);
+void emit_map_add(emitter_t *emit, int map_stack_index);
+void emit_build_set(emitter_t *emit, int n_args);
+void emit_set_add(emitter_t *emit, int set_stack_index);
+void emit_build_slice(emitter_t *emit, int n_args);
+void emit_unpack_sequence(emitter_t *emit, int n_args);
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right);
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
+void emit_return_value(emitter_t *emit);
+void emit_raise_varargs(emitter_t *emit, int n_args);
+void emit_yield_value(emitter_t *emit);
+void emit_yield_from(emitter_t *emit);
diff --git a/py/emitbc.c b/py/emitbc.c
new file mode 100644
index 0000000..9d159ae
--- /dev/null
+++ b/py/emitbc.c
@@ -0,0 +1,692 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "compile.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+#include "bc.h"
+
+#ifdef EMIT_DO_BC
+
+struct _emitter_t {
+    int pass;
+    int next_label;
+    int stack_size;
+    bool last_emit_was_return_value;
+
+    scope_t *scope;
+
+    int max_num_labels;
+    uint *label_offsets;
+
+    uint code_offset;
+    uint code_size;
+    byte *code_base;
+    byte dummy_data[8];
+};
+
+emitter_t *emit_new() {
+    emitter_t *emit = m_new(emitter_t, 1);
+    emit->max_num_labels = 0;
+    emit->label_offsets = NULL;
+    emit->code_offset = 0;
+    emit->code_size = 0;
+    emit->code_base = NULL;
+    return emit;
+}
+
+uint emit_get_code_size(emitter_t* emit) {
+    return emit->code_size;
+}
+
+void* emit_get_code(emitter_t* emit) {
+    return emit->code_base;
+}
+
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
+    emit->pass = pass;
+    emit->next_label = 1;
+    emit->stack_size = 0;
+    emit->last_emit_was_return_value = false;
+    emit->scope = scope;
+    if (pass == PASS_1) {
+        scope->unique_code_id = rt_get_new_unique_code_id();
+    } else if (pass > PASS_1) {
+        if (emit->label_offsets == NULL) {
+            emit->label_offsets = m_new(uint, emit->max_num_labels);
+        }
+        if (pass == PASS_2) {
+            memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint));
+        }
+    }
+    emit->code_offset = 0;
+}
+
+void emit_end_pass(emitter_t *emit) {
+    // check stack is back to zero size
+    if (emit->stack_size != 0) {
+        printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
+    }
+
+    if (emit->pass == PASS_1) {
+        // calculate number of labels need
+        if (emit->next_label > emit->max_num_labels) {
+            emit->max_num_labels = emit->next_label;
+        }
+
+    } else if (emit->pass == PASS_2) {
+        // calculate size of code in bytes
+        emit->code_size = emit->code_offset;
+        emit->code_base = m_new(byte, emit->code_size);
+        printf("code_size: %u\n", emit->code_size);
+
+    } else if (emit->pass == PASS_3) {
+        rt_assign_byte_code(emit->scope->unique_code_id, emit->code_base, emit->code_size, emit->scope->num_params);
+    }
+}
+
+// all functions must go through this one to emit bytes
+static byte* emit_get_cur_to_write_bytes(emitter_t* emit, int num_bytes_to_write) {
+    //printf("emit %d\n", num_bytes_to_write);
+    if (emit->pass < PASS_3) {
+        emit->code_offset += num_bytes_to_write;
+        return emit->dummy_data;
+    } else {
+        assert(emit->code_offset + num_bytes_to_write <= emit->code_size);
+        byte *c = emit->code_base + emit->code_offset;
+        emit->code_offset += num_bytes_to_write;
+        return c;
+    }
+}
+
+static void emit_write_byte_1(emitter_t* emit, byte b1) {
+    byte* c = emit_get_cur_to_write_bytes(emit, 1);
+    c[0] = b1;
+}
+
+static void emit_write_byte_1_byte(emitter_t* emit, byte b1, uint b2) {
+    assert((b2 & (~0xff)) == 0);
+    byte* c = emit_get_cur_to_write_bytes(emit, 2);
+    c[0] = b1;
+    c[1] = b2;
+}
+
+static void emit_write_byte_1_int(emitter_t* emit, byte b1, int num) {
+    assert((num & (~0x7fff)) == 0 || (num & (~0x7fff)) == (~0x7fff));
+    byte* c = emit_get_cur_to_write_bytes(emit, 3);
+    c[0] = b1;
+    c[1] = num;
+    c[2] = num >> 8;
+}
+
+static void emit_write_byte_1_uint(emitter_t* emit, byte b1, uint num) {
+    if (num <= 127) { // fits in 0x7f
+        // fit argument in single byte
+        byte* c = emit_get_cur_to_write_bytes(emit, 2);
+        c[0] = b1;
+        c[1] = num;
+    } else if (num <= 16383) { // fits in 0x3fff
+        // fit argument in two bytes
+        byte* c = emit_get_cur_to_write_bytes(emit, 3);
+        c[0] = b1;
+        c[1] = (num >> 8) | 0x80;
+        c[2] = num;
+    } else {
+        // larger numbers not implemented/supported
+        assert(0);
+    }
+}
+
+static void emit_write_byte_1_qstr(emitter_t* emit, byte b1, qstr qstr) {
+    emit_write_byte_1_uint(emit, b1, qstr);
+}
+
+static void emit_write_byte_1_label(emitter_t* emit, byte b1, int label) {
+    uint code_offset;
+    if (emit->pass < PASS_3) {
+        code_offset = 0;
+    } else {
+        code_offset = emit->label_offsets[label];
+    }
+    emit_write_byte_1_uint(emit, b1, code_offset);
+}
+
+bool emit_last_emit_was_return_value(emitter_t *emit) {
+    return emit->last_emit_was_return_value;
+}
+
+int emit_get_stack_size(emitter_t *emit) {
+    return emit->stack_size;
+}
+
+void emit_set_stack_size(emitter_t *emit, int size) {
+    if (emit->pass > PASS_1) {
+        emit->stack_size = size;
+    }
+}
+
+static void emit_pre(emitter_t *emit, int stack_size_delta) {
+    if (emit->pass > PASS_1) {
+        emit->stack_size += stack_size_delta;
+        if (emit->stack_size > emit->scope->stack_size) {
+            emit->scope->stack_size = emit->stack_size;
+        }
+    }
+    emit->last_emit_was_return_value = false;
+}
+
+int emit_label_new(emitter_t *emit) {
+    return emit->next_label++;
+}
+
+void emit_label_assign(emitter_t *emit, int l) {
+    emit_pre(emit, 0);
+    if (emit->pass > PASS_1) {
+        assert(l < emit->max_num_labels);
+        if (emit->pass == PASS_2) {
+            // assign label offset
+            assert(emit->label_offsets[l] == -1);
+            emit->label_offsets[l] = emit->code_offset;
+        } else if (emit->pass == PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            assert(emit->label_offsets[l] == emit->code_offset);
+            //printf("l%d: (at %d)\n", l, emit->code_offset);
+        }
+    }
+}
+
+void emit_import_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_qstr(emit, PYBC_IMPORT_NAME, qstr);
+}
+
+void emit_import_from(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_IMPORT_FROM, qstr);
+}
+
+void emit_import_star(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_IMPORT_STAR);
+}
+
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
+    emit_pre(emit, 1);
+    switch (tok) {
+        case PY_TOKEN_KW_FALSE: emit_write_byte_1(emit, PYBC_LOAD_CONST_FALSE); break;
+        case PY_TOKEN_KW_NONE: emit_write_byte_1(emit, PYBC_LOAD_CONST_NONE); break;
+        case PY_TOKEN_KW_TRUE: emit_write_byte_1(emit, PYBC_LOAD_CONST_TRUE); break;
+        default: assert(0);
+    }
+}
+
+void emit_load_const_small_int(emitter_t *emit, int arg) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_int(emit, PYBC_LOAD_CONST_SMALL_INT, arg);
+}
+
+void emit_load_const_int(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_INT, qstr);
+}
+
+void emit_load_const_dec(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_DEC, qstr);
+}
+
+void emit_load_const_id(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_ID, qstr);
+}
+
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) {
+    emit_pre(emit, 1);
+    if (bytes) {
+        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_BYTES, qstr);
+    } else {
+        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_STRING, qstr);
+    }
+}
+
+void emit_load_const_verbatim_start(emitter_t *emit) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_const_verbatim_int(emitter_t *emit, int val) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_end(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(local_num >= 0);
+    emit_pre(emit, 1);
+    switch (local_num) {
+        case 0: emit_write_byte_1(emit, PYBC_LOAD_FAST_0); break;
+        case 1: emit_write_byte_1(emit, PYBC_LOAD_FAST_1); break;
+        case 2: emit_write_byte_1(emit, PYBC_LOAD_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, PYBC_LOAD_FAST_N, local_num); break;
+    }
+}
+
+void emit_load_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_NAME, qstr);
+}
+
+void emit_load_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_GLOBAL, qstr);
+}
+
+void emit_load_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_closure(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_ATTR, qstr);
+}
+
+void emit_load_method(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_METHOD, qstr);
+}
+
+void emit_load_build_class(emitter_t *emit) {
+    emit_pre(emit, 1);
+    emit_write_byte_1(emit, PYBC_LOAD_BUILD_CLASS);
+}
+
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(local_num >= 0);
+    emit_pre(emit, -1);
+    switch (local_num) {
+        case 0: emit_write_byte_1(emit, PYBC_STORE_FAST_0); break;
+        case 1: emit_write_byte_1(emit, PYBC_STORE_FAST_1); break;
+        case 2: emit_write_byte_1(emit, PYBC_STORE_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, PYBC_STORE_FAST_N, local_num); break;
+    }
+}
+
+void emit_store_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_qstr(emit, PYBC_STORE_NAME, qstr);
+}
+
+void emit_store_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_qstr(emit, PYBC_STORE_GLOBAL, qstr);
+}
+
+void emit_store_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    assert(0);
+}
+
+void emit_store_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -2);
+    emit_write_byte_1_qstr(emit, PYBC_STORE_ATTR, qstr);
+}
+
+void emit_store_locals(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_STORE_LOCALS);
+}
+
+void emit_store_subscr(emitter_t *emit) {
+    emit_pre(emit, -3);
+    emit_write_byte_1(emit, PYBC_STORE_SUBSCR);
+}
+
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(local_num >= 0);
+    emit_pre(emit, 0);
+    emit_write_byte_1_uint(emit, PYBC_DELETE_FAST_N, local_num);
+}
+
+void emit_delete_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_NAME, qstr);
+}
+
+void emit_delete_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_GLOBAL, qstr);
+}
+
+void emit_delete_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_DEREF, qstr);
+}
+
+void emit_delete_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_ATTR, qstr);
+}
+
+void emit_delete_subscr(emitter_t *emit) {
+    emit_pre(emit, -2);
+    emit_write_byte_1(emit, PYBC_DELETE_SUBSCR);
+}
+
+void emit_dup_top(emitter_t *emit) {
+    emit_pre(emit, 1);
+    emit_write_byte_1(emit, PYBC_DUP_TOP);
+}
+
+void emit_dup_top_two(emitter_t *emit) {
+    emit_pre(emit, 2);
+    emit_write_byte_1(emit, PYBC_DUP_TOP_TWO);
+}
+
+void emit_pop_top(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_POP_TOP);
+}
+
+void emit_rot_two(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_ROT_TWO);
+}
+
+void emit_rot_three(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_ROT_THREE);
+}
+
+void emit_jump(emitter_t *emit, int label) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_JUMP, label);
+}
+
+void emit_pop_jump_if_true(emitter_t *emit, int label) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_TRUE, label);
+}
+
+void emit_pop_jump_if_false(emitter_t *emit, int label) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_FALSE, label);
+}
+
+void emit_jump_if_true_or_pop(emitter_t *emit, int label) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_label(emit, PYBC_JUMP_IF_TRUE_OR_POP, label);
+}
+
+void emit_jump_if_false_or_pop(emitter_t *emit, int label) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_label(emit, PYBC_JUMP_IF_FALSE_OR_POP, label);
+}
+
+void emit_setup_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_SETUP_LOOP, label);
+}
+
+void emit_break_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_BREAK_LOOP, label);
+}
+
+void emit_continue_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_CONTINUE_LOOP, label);
+}
+
+void emit_setup_with(emitter_t *emit, int label) {
+    emit_pre(emit, 7);
+    emit_write_byte_1_label(emit, PYBC_SETUP_WITH, label);
+}
+
+void emit_with_cleanup(emitter_t *emit) {
+    emit_pre(emit, -7);
+    emit_write_byte_1(emit, PYBC_WITH_CLEANUP);
+}
+
+void emit_setup_except(emitter_t *emit, int label) {
+    emit_pre(emit, 6);
+    emit_write_byte_1_label(emit, PYBC_SETUP_EXCEPT, label);
+}
+
+void emit_setup_finally(emitter_t *emit, int label) {
+    emit_pre(emit, 6);
+    emit_write_byte_1_label(emit, PYBC_SETUP_FINALLY, label);
+}
+
+void emit_end_finally(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_END_FINALLY);
+}
+
+void emit_get_iter(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_GET_ITER);
+}
+
+void emit_for_iter(emitter_t *emit, int label) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_label(emit, PYBC_FOR_ITER, label);
+}
+
+void emit_for_iter_end(emitter_t *emit) {
+    emit_pre(emit, -1);
+}
+
+void emit_pop_block(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_POP_BLOCK);
+}
+
+void emit_pop_except(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_POP_EXCEPT);
+}
+
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_byte(emit, PYBC_UNARY_OP, op);
+}
+
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_byte(emit, PYBC_BINARY_OP, op);
+}
+
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_byte(emit, PYBC_COMPARE_OP, op);
+}
+
+void emit_build_tuple(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, 1 - n_args);
+    emit_write_byte_1_uint(emit, PYBC_BUILD_TUPLE, n_args);
+}
+
+void emit_build_list(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, 1 - n_args);
+    emit_write_byte_1_uint(emit, PYBC_BUILD_LIST, n_args);
+}
+
+void emit_list_append(emitter_t *emit, int list_stack_index) {
+    assert(list_stack_index >= 0);
+    emit_pre(emit, -1);
+    emit_write_byte_1_uint(emit, PYBC_LIST_APPEND, list_stack_index);
+}
+
+void emit_build_map(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, 1);
+    emit_write_byte_1_uint(emit, PYBC_BUILD_MAP, n_args);
+}
+
+void emit_store_map(emitter_t *emit) {
+    emit_pre(emit, -2);
+    emit_write_byte_1(emit, PYBC_STORE_MAP);
+}
+
+void emit_map_add(emitter_t *emit, int map_stack_index) {
+    assert(map_stack_index >= 0);
+    emit_pre(emit, -2);
+    emit_write_byte_1_uint(emit, PYBC_MAP_ADD, map_stack_index);
+}
+
+void emit_build_set(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, 1 - n_args);
+    emit_write_byte_1_uint(emit, PYBC_BUILD_SET, n_args);
+}
+
+void emit_set_add(emitter_t *emit, int set_stack_index) {
+    assert(set_stack_index >= 0);
+    emit_pre(emit, -1);
+    emit_write_byte_1_uint(emit, PYBC_SET_ADD, set_stack_index);
+}
+
+void emit_build_slice(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, 1 - n_args);
+    emit_write_byte_1_uint(emit, PYBC_BUILD_SLICE, n_args);
+}
+
+void emit_unpack_sequence(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, -1 + n_args);
+    emit_write_byte_1_uint(emit, PYBC_UNPACK_SEQUENCE, n_args);
+}
+
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) {
+    assert(n_left >=0 && n_right >= 0);
+    emit_pre(emit, -1 + n_left + n_right + 1);
+    emit_write_byte_1_uint(emit, PYBC_UNPACK_EX, n_left | (n_right << 8));
+}
+
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(n_default_params == 0 && n_dict_params == 0);
+    emit_pre(emit, 1);
+    emit_write_byte_1_uint(emit, PYBC_MAKE_FUNCTION, scope->unique_code_id);
+}
+
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(0);
+    emit_pre(emit, -2 - n_default_params - 2 * n_dict_params);
+    if (emit->pass == PASS_3) {
+        printf("MAKE_CLOSURE %d\n", (n_dict_params << 8) | n_default_params);
+    }
+}
+
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    int s = 0;
+    if (have_star_arg) {
+        s += 1;
+    }
+    if (have_dbl_star_arg) {
+        s += 1;
+    }
+    emit_pre(emit, -n_positional - 2 * n_keyword - s);
+    int op;
+    if (have_star_arg) {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_FUNCTION_VAR_KW;
+        } else {
+            op = PYBC_CALL_FUNCTION_VAR;
+        }
+    } else {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_FUNCTION_KW;
+        } else {
+            op = PYBC_CALL_FUNCTION;
+        }
+    }
+    emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
+}
+
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    int s = 0;
+    if (have_star_arg) {
+        s += 1;
+    }
+    if (have_dbl_star_arg) {
+        s += 1;
+    }
+    emit_pre(emit, -n_positional - 2 * n_keyword - s);
+    int op;
+    if (have_star_arg) {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_METHOD_VAR_KW;
+        } else {
+            op = PYBC_CALL_METHOD_VAR;
+        }
+    } else {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_METHOD_KW;
+        } else {
+            op = PYBC_CALL_METHOD;
+        }
+    }
+    emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
+}
+
+void emit_return_value(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit->last_emit_was_return_value = true;
+    emit_write_byte_1(emit, PYBC_RETURN_VALUE);
+}
+
+void emit_raise_varargs(emitter_t *emit, int n_args) {
+    assert(n_args >= 0);
+    emit_pre(emit, -n_args);
+    emit_write_byte_1_uint(emit, PYBC_RAISE_VARARGS, n_args);
+}
+
+void emit_yield_value(emitter_t *emit) {
+    emit_pre(emit, 0);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    emit_write_byte_1(emit, PYBC_YIELD_VALUE);
+}
+
+void emit_yield_from(emitter_t *emit) {
+    emit_pre(emit, -1);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    emit_write_byte_1(emit, PYBC_YIELD_FROM);
+}
+
+#endif // EMIT_DO_BC
diff --git a/py/emitcommon.c b/py/emitcommon.c
new file mode 100644
index 0000000..1fd8697
--- /dev/null
+++ b/py/emitcommon.c
@@ -0,0 +1,171 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+
+#define EMIT(fun, arg...) (emit_##fun(emit, ##arg))
+
+void emit_common_declare_global(pass_kind_t pass, scope_t *scope, qstr qstr) {
+    if (pass == PASS_1) {
+        if (scope->kind == SCOPE_MODULE) {
+            printf("SyntaxError?: can't declare global in outer code\n");
+            return;
+        }
+        bool added;
+        id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
+        if (!added) {
+            printf("SyntaxError?: identifier already declared something\n");
+            return;
+        }
+        id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
+
+        // if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
+        id_info = scope_find_global(scope, qstr);
+        if (id_info != NULL) {
+            id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
+        }
+    }
+}
+
+void emit_common_declare_nonlocal(pass_kind_t pass, scope_t *scope, qstr qstr) {
+    if (pass == PASS_1) {
+        if (scope->kind == SCOPE_MODULE) {
+            printf("SyntaxError?: can't declare nonlocal in outer code\n");
+            return;
+        }
+        bool added;
+        id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
+        if (!added) {
+            printf("SyntaxError?: identifier already declared something\n");
+            return;
+        }
+        id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr);
+        if (id_info2 == NULL || !(id_info2->kind == ID_INFO_KIND_LOCAL || id_info2->kind == ID_INFO_KIND_CELL || id_info2->kind == ID_INFO_KIND_FREE)) {
+            printf("SyntaxError: no binding for nonlocal '%s' found\n", qstr_str(qstr));
+            return;
+        }
+        id_info->kind = ID_INFO_KIND_FREE;
+        scope_close_over_in_parents(scope, qstr);
+    }
+}
+
+void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__, emitter_t *emit, qstr qstr) {
+    id_info_t *id_info = NULL;
+    if (pass == PASS_1) {
+        // name adding/lookup
+        bool added;
+        id_info = scope_find_or_add_id(scope, qstr, &added);
+        if (added) {
+            if (strcmp(qstr_str(qstr), "AssertionError") == 0) {
+                id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
+                // TODO how much of a hack is this?
+            } else if (strcmp(qstr_str(qstr), "super") == 0 && scope->kind == SCOPE_FUNCTION) {
+                // special case, super is a global, and also counts as use of __class__
+                id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
+                id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr___class__);
+                if (id_info2 != NULL) {
+                    id_info2 = scope_find_or_add_id(scope, qstr___class__, &added);
+                    if (added) {
+                        id_info2->kind = ID_INFO_KIND_FREE;
+                        scope_close_over_in_parents(scope, qstr___class__);
+                    }
+                }
+            } else {
+                id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr);
+                if (id_info2 != NULL && (id_info2->kind == ID_INFO_KIND_LOCAL || id_info2->kind == ID_INFO_KIND_CELL || id_info2->kind == ID_INFO_KIND_FREE)) {
+                    id_info->kind = ID_INFO_KIND_FREE;
+                    scope_close_over_in_parents(scope, qstr);
+                } else {
+                    id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
+                }
+            }
+        }
+    } else {
+        id_info = scope_find(scope, qstr);
+    }
+
+    assert(id_info != NULL); // TODO can this ever fail?
+
+    // call the emit backend with the correct code
+    if (id_info == NULL || id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+        EMIT(load_name, qstr);
+    } else if (id_info->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
+        EMIT(load_global, qstr);
+    } else if (id_info->kind == ID_INFO_KIND_LOCAL) {
+        EMIT(load_fast, qstr, id_info->local_num);
+    } else if (id_info->kind == ID_INFO_KIND_CELL || id_info->kind == ID_INFO_KIND_FREE) {
+        EMIT(load_deref, qstr);
+    } else {
+        assert(0);
+    }
+}
+
+static id_info_t *get_id_for_modification(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) {
+    id_info_t *id_info = NULL;
+    if (pass == PASS_1) {
+        // name adding/lookup
+        bool added;
+        id_info = scope_find_or_add_id(scope, qstr, &added);
+        if (added) {
+            if (scope->kind == SCOPE_MODULE || scope->kind == SCOPE_CLASS) {
+                id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
+            } else {
+                id_info->kind = ID_INFO_KIND_LOCAL;
+            }
+        } else if (scope->kind >= SCOPE_FUNCTION && scope->kind <= SCOPE_GEN_EXPR && id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+            // rebind as a local variable
+            id_info->kind = ID_INFO_KIND_LOCAL;
+        }
+    } else {
+        id_info = scope_find(scope, qstr);
+    }
+
+    assert(id_info != NULL); // TODO can this ever fail?
+
+    return id_info;
+}
+
+void emit_common_store_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) {
+    // create/get the id info
+    id_info_t *id = get_id_for_modification(pass, scope, emit, qstr);
+
+    // call the emit backend with the correct code
+    if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+        EMIT(store_name, qstr);
+    } else if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
+        EMIT(store_global, qstr);
+    } else if (id->kind == ID_INFO_KIND_LOCAL) {
+        EMIT(store_fast, qstr, id->local_num);
+    } else if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
+        EMIT(store_deref, qstr);
+    } else {
+        assert(0);
+    }
+}
+
+void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) {
+    // create/get the id info
+    id_info_t *id = get_id_for_modification(pass, scope, emit, qstr);
+
+    // call the emit backend with the correct code
+    if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+        EMIT(delete_name, qstr);
+    } else if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
+        EMIT(delete_global, qstr);
+    } else if (id->kind == ID_INFO_KIND_LOCAL) {
+        EMIT(delete_fast, qstr, id->local_num);
+    } else if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
+        EMIT(delete_deref, qstr);
+    } else {
+        assert(0);
+    }
+}
diff --git a/py/emitcpy.c b/py/emitcpy.c
new file mode 100644
index 0000000..637abd7
--- /dev/null
+++ b/py/emitcpy.c
@@ -0,0 +1,834 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "compile.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+
+#ifdef EMIT_DO_CPY
+
+struct _emitter_t {
+    int pass;
+    int next_label;
+    int byte_code_offset;
+    int stack_size;
+    bool last_emit_was_return_value;
+
+    scope_t *scope;
+
+    int max_num_labels;
+    int *label_offsets;
+};
+
+emitter_t *emit_new() {
+    emitter_t *emit = m_new(emitter_t, 1);
+    emit->max_num_labels = 0;
+    emit->label_offsets = NULL;
+    return emit;
+}
+
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
+    emit->pass = pass;
+    emit->next_label = 1;
+    emit->byte_code_offset = 0;
+    emit->stack_size = 0;
+    emit->last_emit_was_return_value = false;
+    emit->scope = scope;
+    if (pass > PASS_1) {
+        if (emit->label_offsets == NULL) {
+            emit->label_offsets = m_new(int, emit->max_num_labels);
+        }
+        if (pass == PASS_2) {
+            memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(int));
+        }
+    }
+}
+
+void emit_end_pass(emitter_t *emit) {
+    // check stack is back to zero size
+    if (emit->stack_size != 0) {
+        printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
+    }
+
+    // calculate number of labels need
+    if (emit->pass == PASS_1) {
+        if (emit->next_label > emit->max_num_labels) {
+            emit->max_num_labels = emit->next_label;
+        }
+    }
+}
+
+bool emit_last_emit_was_return_value(emitter_t *emit) {
+    return emit->last_emit_was_return_value;
+}
+
+int emit_get_stack_size(emitter_t *emit) {
+    return emit->stack_size;
+}
+
+void emit_set_stack_size(emitter_t *emit, int size) {
+    emit->stack_size = size;
+}
+
+static void emit_pre(emitter_t *emit, int stack_size_delta, int byte_code_size) {
+    emit->stack_size += stack_size_delta;
+    if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) {
+        emit->scope->stack_size = emit->stack_size;
+    }
+    emit->last_emit_was_return_value = false;
+    if (emit->pass == PASS_3 && byte_code_size > 0) {
+        if (emit->byte_code_offset >= 1000) {
+            printf("%d ", emit->byte_code_offset);
+        } else {
+            printf("% 4d ", emit->byte_code_offset);
+        }
+    }
+    emit->byte_code_offset += byte_code_size;
+}
+
+int emit_label_new(emitter_t *emit) {
+    return emit->next_label++;
+}
+
+void emit_label_assign(emitter_t *emit, int l) {
+    emit_pre(emit, 0, 0);
+    if (emit->pass > PASS_1) {
+        assert(l < emit->max_num_labels);
+        if (emit->pass == PASS_2) {
+            // assign label offset
+            assert(emit->label_offsets[l] == -1);
+            emit->label_offsets[l] = emit->byte_code_offset;
+        } else if (emit->pass == PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            assert(emit->label_offsets[l] == emit->byte_code_offset);
+            //printf("l%d: (at %d)\n", l, emit->byte_code_offset);
+        }
+    }
+}
+
+void emit_import_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("IMPORT_NAME %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_import_from(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("IMPORT_FROM %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_import_star(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_3) {
+        printf("IMPORT_STAR\n");
+    }
+}
+
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST ");
+        switch (tok) {
+            case PY_TOKEN_KW_FALSE: printf("False"); break;
+            case PY_TOKEN_KW_NONE: printf("None"); break;
+            case PY_TOKEN_KW_TRUE: printf("True"); break;
+            default: printf("?=%d\n", tok); return; assert(0);
+        }
+        printf("\n");
+    }
+}
+
+void emit_load_const_small_int(emitter_t *emit, int arg) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST %d\n", arg);
+    }
+}
+
+void emit_load_const_int(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_const_dec(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_const_id(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST '%s'\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST ");
+        emit_load_const_verbatim_quoted_str(emit, qstr, bytes);
+        printf("\n");
+    }
+}
+
+void emit_load_const_verbatim_start(emitter_t *emit) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST ");
+    }
+}
+
+void emit_load_const_verbatim_int(emitter_t *emit, int val) {
+    if (emit->pass == PASS_3) {
+        printf("%d", val);
+    }
+}
+
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str) {
+    if (emit->pass == PASS_3) {
+        printf("%s", str);
+    }
+}
+
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) {
+    if (emit->pass == PASS_3) {
+        printf("%.*s", len, str);
+    }
+}
+
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) {
+    // TODO strings should be escaped before we get here
+    if (emit->pass == PASS_3) {
+        const char *str = qstr_str(qstr);
+        int len = strlen(str);
+        bool has_single_quote = false;
+        bool has_double_quote = false;
+        for (int i = 0; i < len; i++) {
+            if (str[i] == '\'') {
+                has_single_quote = true;
+            } else if (str[i] == '"') {
+                has_double_quote = true;
+            }
+        }
+        if (bytes) {
+            printf("b");
+        }
+        bool quote_single = false;
+        if (has_single_quote && !has_double_quote) {
+            printf("\"");
+        } else {
+            quote_single = true;
+            printf("'");
+        }
+        for (int i = 0; i < len; i++) {
+            if (str[i] == '\n') {
+                printf("\\n");
+            } else if (str[i] == '\\' && str[i + 1] == '\'') {
+                i += 1;
+                if (quote_single) {
+                    printf("\\'");
+                } else {
+                    printf("'");
+                }
+            } else if (str[i] == '\'' && quote_single) {
+                printf("\\'");
+            } else {
+                printf("%c", str[i]);
+            }
+        }
+        if (has_single_quote && !has_double_quote) {
+            printf("\"");
+        } else {
+            printf("'");
+        }
+    }
+}
+
+void emit_load_const_verbatim_end(emitter_t *emit) {
+    if (emit->pass == PASS_3) {
+        printf("\n");
+    }
+}
+
+void emit_load_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_NAME %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_GLOBAL %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_FAST %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_DEREF %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_closure(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CLOSURE %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_ATTR %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_load_method(emitter_t *emit, qstr qstr) {
+    emit_load_attr(emit, qstr);
+}
+
+void emit_load_build_class(emitter_t *emit) {
+    emit_pre(emit, 1, 1);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_BUILD_CLASS\n");
+    }
+}
+
+void emit_store_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("STORE_NAME %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_store_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("STORE_GLOBAL %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("STORE_FAST %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_store_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("STORE_DEREF %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_store_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -2, 3);
+    if (emit->pass == PASS_3) {
+        printf("STORE_ATTR %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_store_locals(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_3) {
+        printf("STORE_LOCALS\n");
+    }
+}
+
+void emit_store_subscr(emitter_t *emit) {
+    emit_pre(emit, -3, 1);
+    if (emit->pass == PASS_3) {
+        printf("STORE_SUBSCR\n");
+    }
+}
+
+void emit_delete_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_NAME %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_delete_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_GLOBAL %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_FAST %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_delete_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_DEREF %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_delete_attr(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_ATTR %s\n", qstr_str(qstr));
+    }
+}
+
+void emit_delete_subscr(emitter_t *emit) {
+    emit_pre(emit, -2, 1);
+    if (emit->pass == PASS_3) {
+        printf("DELETE_SUBSCR\n");
+    }
+}
+
+void emit_dup_top(emitter_t *emit) {
+    emit_pre(emit, 1, 1);
+    if (emit->pass == PASS_3) {
+        printf("DUP_TOP\n");
+    }
+}
+
+void emit_dup_top_two(emitter_t *emit) {
+    emit_pre(emit, 2, 1);
+    if (emit->pass == PASS_3) {
+        printf("DUP_TOP_TWO\n");
+    }
+}
+
+void emit_pop_top(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_3) {
+        printf("POP_TOP\n");
+    }
+}
+
+void emit_rot_two(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("ROT_TWO\n");
+    }
+}
+
+void emit_rot_three(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("ROT_THREE\n");
+    }
+}
+
+void emit_jump(emitter_t *emit, int label) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        int dest = emit->label_offsets[label];
+        if (dest < emit->byte_code_offset) {
+            printf("JUMP_ABSOLUTE %d\n", emit->label_offsets[label]);
+        } else {
+            printf("JUMP_FORWARD %d\n", emit->label_offsets[label]);
+        }
+    }
+}
+
+void emit_pop_jump_if_true(emitter_t *emit, int label) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("POP_JUMP_IF_TRUE %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_pop_jump_if_false(emitter_t *emit, int label) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("POP_JUMP_IF_FALSE %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_jump_if_true_or_pop(emitter_t *emit, int label) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("JUMP_IF_TRUE_OR_POP %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_jump_if_false_or_pop(emitter_t *emit, int label) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("JUMP_IF_FALSE_OR_POP %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_setup_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("SETUP_LOOP %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_break_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("BREAK_LOOP\n"); // CPython doesn't have label
+        //printf("BREAK_LOOP %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_continue_loop(emitter_t *emit, int label) {
+    emit_pre(emit, 0, 3);
+    if (emit->pass == PASS_3) {
+        printf("CONTINUE_LOOP %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_setup_with(emitter_t *emit, int label) {
+    emit_pre(emit, 7, 3);
+    if (emit->pass == PASS_3) {
+        printf("SETUP_WITH %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_with_cleanup(emitter_t *emit) {
+    emit_pre(emit, -7, 1);
+    if (emit->pass == PASS_3) {
+        printf("WITH_CLEANUP\n");
+    }
+}
+
+void emit_setup_except(emitter_t *emit, int label) {
+    emit_pre(emit, 6, 3);
+    if (emit->pass == PASS_3) {
+        printf("SETUP_EXCEPT %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_setup_finally(emitter_t *emit, int label) {
+    emit_pre(emit, 6, 3);
+    if (emit->pass == PASS_3) {
+        printf("SETUP_FINALLY %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_end_finally(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_3) {
+        printf("END_FINALLY\n");
+    }
+}
+
+void emit_get_iter(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("GET_ITER\n");
+    }
+}
+
+void emit_for_iter(emitter_t *emit, int label) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("FOR_ITER %d\n", emit->label_offsets[label]);
+    }
+}
+
+void emit_for_iter_end(emitter_t *emit) {
+    emit_pre(emit, -1, 0);
+}
+
+void emit_pop_block(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("POP_BLOCK\n");
+    }
+}
+
+void emit_pop_except(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        printf("POP_EXCEPT\n");
+    }
+}
+
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_3) {
+        switch (op) {
+            case RT_UNARY_OP_NOT: printf("UNARY_NOT\n"); break;
+            case RT_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break;
+            case RT_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break;
+            case RT_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break;
+            default: assert(0);
+        }
+    }
+}
+
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_3) {
+        switch (op) {
+            case RT_BINARY_OP_SUBSCR: printf("BINARY_SUBSCR\n"); break;
+            case RT_BINARY_OP_OR: printf("BINARY_OR\n"); break;
+            case RT_BINARY_OP_XOR: printf("BINARY_XOR\n"); break;
+            case RT_BINARY_OP_AND: printf("BINARY_AND\n"); break;
+            case RT_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break;
+            case RT_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break;
+            case RT_BINARY_OP_ADD: printf("BINARY_ADD\n"); break;
+            case RT_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break;
+            case RT_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break;
+            case RT_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break;
+            case RT_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break;
+            case RT_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break;
+            case RT_BINARY_OP_POWER: printf("BINARY_POWER\n"); break;
+            case RT_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break;
+            case RT_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break;
+            case RT_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break;
+            case RT_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break;
+            case RT_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break;
+            case RT_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break;
+            case RT_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break;
+            case RT_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break;
+            case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: printf("INPLACE_FLOOR_DIVIDE\n"); break;
+            case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: printf("INPLACE_TRUE_DIVIDE\n"); break;
+            case RT_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break;
+            case RT_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break;
+            default: assert(0);
+        }
+    }
+}
+
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        switch (op) {
+            case RT_COMPARE_OP_LESS: printf("COMPARE_OP <\n"); break;
+            case RT_COMPARE_OP_MORE: printf("COMPARE_OP >\n"); break;
+            case RT_COMPARE_OP_EQUAL: printf("COMPARE_OP ==\n"); break;
+            case RT_COMPARE_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break;
+            case RT_COMPARE_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break;
+            case RT_COMPARE_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break;
+            case RT_COMPARE_OP_IN: printf("COMPARE_OP in\n"); break;
+            case RT_COMPARE_OP_NOT_IN: printf("COMPARE_OP not in\n"); break;
+            case RT_COMPARE_OP_IS: printf("COMPARE_OP is\n"); break;
+            case RT_COMPARE_OP_IS_NOT: printf("COMPARE_OP is not\n"); break;
+            case RT_COMPARE_OP_EXCEPTION_MATCH: printf("COMPARE_OP exception match\n"); break;
+            default: assert(0);
+        }
+    }
+}
+
+void emit_build_tuple(emitter_t *emit, int n_args) {
+    emit_pre(emit, 1 - n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("BUILD_TUPLE %d\n", n_args);
+    }
+}
+
+void emit_build_list(emitter_t *emit, int n_args) {
+    emit_pre(emit, 1 - n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("BUILD_LIST %d\n", n_args);
+    }
+}
+
+void emit_list_append(emitter_t *emit, int list_index) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LIST_APPEND %d\n", list_index);
+    }
+}
+
+void emit_build_map(emitter_t *emit, int n_args) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("BUILD_MAP %d\n", n_args);
+    }
+}
+
+void emit_store_map(emitter_t *emit) {
+    emit_pre(emit, -2, 1);
+    if (emit->pass == PASS_3) {
+        printf("STORE_MAP\n");
+    }
+}
+
+void emit_map_add(emitter_t *emit, int map_index) {
+    emit_pre(emit, -2, 3);
+    if (emit->pass == PASS_3) {
+        printf("MAP_ADD %d\n", map_index);
+    }
+}
+
+void emit_build_set(emitter_t *emit, int n_args) {
+    emit_pre(emit, 1 - n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("BUILD_SET %d\n", n_args);
+    }
+}
+
+void emit_set_add(emitter_t *emit, int set_index) {
+    emit_pre(emit, -1, 3);
+    if (emit->pass == PASS_3) {
+        printf("SET_ADD %d\n", set_index);
+    }
+}
+
+void emit_build_slice(emitter_t *emit, int n_args) {
+    emit_pre(emit, 1 - n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("BUILD_SLICE %d\n", n_args);
+    }
+}
+
+void emit_unpack_sequence(emitter_t *emit, int n_args) {
+    emit_pre(emit, -1 + n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("UNPACK_SEQUENCE %d\n", n_args);
+    }
+}
+
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) {
+    emit_pre(emit, -1 + n_left + n_right + 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("UNPACK_EX %d\n", n_left | (n_right << 8));
+    }
+}
+
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    int s = 0;
+    if (have_star_arg) {
+        s += 1;
+    }
+    if (have_dbl_star_arg) {
+        s += 1;
+    }
+    emit_pre(emit, -n_positional - 2 * n_keyword - s, 3);
+    if (emit->pass == PASS_3) {
+        if (have_star_arg) {
+            if (have_dbl_star_arg) {
+                printf("CALL_FUNCTION_VAR_KW");
+            } else {
+                printf("CALL_FUNCTION_VAR");
+            }
+        } else {
+            if (have_dbl_star_arg) {
+                printf("CALL_FUNCTION_KW");
+            } else {
+                printf("CALL_FUNCTION");
+            }
+        }
+        printf(" %d, %d\n", n_positional, n_keyword);
+    }
+}
+
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    emit_call_function(emit, n_positional, n_keyword, have_star_arg, have_dbl_star_arg);
+}
+
+void emit_return_value(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    emit->last_emit_was_return_value = true;
+    if (emit->pass == PASS_3) {
+        printf("RETURN_VALUE\n");
+    }
+}
+
+void emit_raise_varargs(emitter_t *emit, int n_args) {
+    emit_pre(emit, -n_args, 3);
+    if (emit->pass == PASS_3) {
+        printf("RAISE_VARARGS %d\n", n_args);
+    }
+}
+
+void load_const_code_and_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST code %s\n", qstr_str(qstr));
+    }
+    // load qualified name
+    emit_pre(emit, 1, 3);
+    if (emit->pass == PASS_3) {
+        printf("LOAD_CONST '");
+        // code just to work out the qualname (or whatever it is)
+        {
+            int depth = 0;
+            for (scope_t *s = emit->scope; s->parent != NULL; s = s->parent) {
+                depth += 1;
+            }
+            for (int wanted_depth = depth; wanted_depth >= 0; wanted_depth--) {
+                scope_t *s = emit->scope;
+                for (int i = 0; i < wanted_depth; i++) {
+                    s = s->parent;
+                }
+                if (s->kind == SCOPE_FUNCTION) {
+                    printf("%s.<locals>.", qstr_str(s->simple_name));
+                } else if (s->kind == SCOPE_CLASS) {
+                    printf("%s.", qstr_str(s->simple_name));
+                }
+            }
+        }
+        printf("%s'\n", qstr_str(qstr));
+    }
+}
+
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    load_const_code_and_name(emit, scope->simple_name);
+    emit_pre(emit, -1 - n_default_params - 2 * n_dict_params, 3);
+    if (emit->pass == PASS_3) {
+        printf("MAKE_FUNCTION %d\n", (n_dict_params << 8) | n_default_params);
+    }
+}
+
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    load_const_code_and_name(emit, scope->simple_name);
+    emit_pre(emit, -2 - n_default_params - 2 * n_dict_params, 3);
+    if (emit->pass == PASS_3) {
+        printf("MAKE_CLOSURE %d\n", (n_dict_params << 8) | n_default_params);
+    }
+}
+
+void emit_yield_value(emitter_t *emit) {
+    emit_pre(emit, 0, 1);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    if (emit->pass == PASS_3) {
+        printf("YIELD_VALUE\n");
+    }
+}
+
+void emit_yield_from(emitter_t *emit) {
+    emit_pre(emit, -1, 1);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    if (emit->pass == PASS_3) {
+        printf("YIELD_FROM\n");
+    }
+}
+
+#endif // EMIT_DO_CPY
diff --git a/py/emitthumb.c b/py/emitthumb.c
new file mode 100644
index 0000000..cad6b65
--- /dev/null
+++ b/py/emitthumb.c
@@ -0,0 +1,673 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+#include "asmthumb.h"
+
+#ifdef EMIT_DO_THUMB
+
+#define REG_LOCAL_1 (REG_R4)
+#define REG_LOCAL_2 (REG_R5)
+#define REG_LOCAL_3 (REG_R6)
+#define REG_TEMP    (REG_R7)
+#define REG_LOCAL_NUM (3)
+
+typedef enum {
+    NEED_TO_PUSH_NOTHING,
+    NEED_TO_PUSH_REG,
+    NEED_TO_PUSH_I32,
+} need_to_push_t;
+
+struct _emitter_t {
+    int pass;
+    int stack_start;
+    int stack_size;
+    bool last_emit_was_return_value;
+    need_to_push_t need_to_push;
+    int last_reg;
+    int32_t last_i32;
+
+    scope_t *scope;
+
+    asm_thumb_t *as;
+    bool do_native_types;
+};
+
+emitter_t *emit_new() {
+    emitter_t *emit = m_new(emitter_t, 1);
+    emit->as = asm_thumb_new();
+    emit->do_native_types = true;
+    return emit;
+}
+
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
+    emit->pass = pass;
+    emit->stack_start = 0;
+    emit->stack_size = 0;
+    emit->last_emit_was_return_value = false;
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+    emit->scope = scope;
+    if (pass == PASS_1) {
+        scope->unique_code_id = rt_get_new_unique_code_id();
+    }
+
+    asm_thumb_start_pass(emit->as, pass);
+
+    // entry to function
+    int num_locals = 0;
+    if (pass > PASS_1) {
+        num_locals = scope->num_locals - REG_LOCAL_NUM;
+        if (num_locals < 0) {
+            num_locals = 0;
+        }
+        emit->stack_start = num_locals;
+        num_locals += scope->stack_size;
+    }
+    asm_thumb_entry(emit->as, num_locals);
+
+    // initialise locals from parameters
+    for (int i = 0; i < scope->num_params; i++) {
+        if (i == 0) {
+            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_1, REG_ARG_1);
+        } else if (i == 1) {
+            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_2, REG_ARG_2);
+        } else if (i == 2) {
+            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_3, REG_ARG_3);
+        } else if (i == 3) {
+            asm_thumb_mov_local_reg(emit->as, i - REG_LOCAL_NUM, REG_ARG_4);
+        } else {
+            // TODO not implemented
+            assert(0);
+        }
+    }
+
+    asm_thumb_mov_reg_i32(emit->as, REG_R7, (machine_uint_t)rt_fun_table);
+}
+
+void emit_end_pass(emitter_t *emit) {
+    if (!emit->last_emit_was_return_value) {
+        asm_thumb_exit(emit->as);
+    }
+    asm_thumb_end_pass(emit->as);
+
+    // check stack is back to zero size
+    if (emit->stack_size != 0) {
+        printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
+    }
+
+    if (emit->pass == PASS_3) {
+        py_fun_t f = asm_thumb_get_code(emit->as);
+        rt_assign_native_code(emit->scope->unique_code_id, f, asm_thumb_get_code_size(emit->as), emit->scope->num_params);
+    }
+}
+
+bool emit_last_emit_was_return_value(emitter_t *emit) {
+    return emit->last_emit_was_return_value;
+}
+
+int emit_get_stack_size(emitter_t *emit) {
+    return emit->stack_size;
+}
+
+void emit_set_stack_size(emitter_t *emit, int size) {
+    emit->stack_size = size;
+}
+
+static void adjust_stack(emitter_t *emit, int stack_size_delta) {
+    emit->stack_size += stack_size_delta;
+    assert(emit->stack_size >= 0);
+    if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) {
+        emit->scope->stack_size = emit->stack_size;
+    }
+}
+
+static void stack_settle(emitter_t *emit) {
+    switch (emit->need_to_push) {
+        case NEED_TO_PUSH_NOTHING:
+            break;
+
+        case NEED_TO_PUSH_REG:
+            asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, emit->last_reg);
+            adjust_stack(emit, 1);
+            break;
+
+        case NEED_TO_PUSH_I32:
+            asm_thumb_mov_reg_i32_optimised(emit->as, REG_R0, emit->last_i32);
+            asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, REG_R0);
+            adjust_stack(emit, 1);
+            break;
+    }
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+}
+
+static void emit_pre_raw(emitter_t *emit, int stack_size_delta) {
+    adjust_stack(emit, stack_size_delta);
+    emit->last_emit_was_return_value = false;
+}
+
+static void emit_pre(emitter_t *emit) {
+    stack_settle(emit);
+    emit_pre_raw(emit, 0);
+}
+
+static void emit_pre_pop_reg(emitter_t *emit, int reg_dest) {
+    switch (emit->need_to_push) {
+        case NEED_TO_PUSH_NOTHING:
+            asm_thumb_mov_reg_local(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1);
+            emit_pre_raw(emit, -1);
+            break;
+
+        case NEED_TO_PUSH_REG:
+            emit_pre_raw(emit, 0);
+            if (emit->last_reg != reg_dest) {
+                asm_thumb_mov_reg_reg(emit->as, reg_dest, emit->last_reg);
+            }
+            break;
+
+        case NEED_TO_PUSH_I32:
+            emit_pre_raw(emit, 0);
+            asm_thumb_mov_reg_i32_optimised(emit->as, reg_dest, emit->last_i32);
+            break;
+    }
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+}
+
+static void emit_pre_pop_reg_reg(emitter_t *emit, int rega, int regb) {
+    emit_pre_pop_reg(emit, rega);
+    asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1);
+    adjust_stack(emit, -1);
+}
+
+static void emit_pre_pop_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc) {
+    emit_pre_pop_reg(emit, rega);
+    asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1);
+    asm_thumb_mov_reg_local(emit->as, regc, emit->stack_start + emit->stack_size - 2);
+    adjust_stack(emit, -2);
+}
+
+static void emit_post(emitter_t *emit) {
+}
+
+static void emit_post_push_reg(emitter_t *emit, int reg) {
+    emit->need_to_push = NEED_TO_PUSH_REG;
+    emit->last_reg = reg;
+}
+
+static void emit_post_push_i32(emitter_t *emit, int32_t i32) {
+    emit->need_to_push = NEED_TO_PUSH_I32;
+    emit->last_i32 = i32;
+}
+
+static void emit_post_push_reg_reg(emitter_t *emit, int rega, int regb) {
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
+    emit->need_to_push = NEED_TO_PUSH_REG;
+    emit->last_reg = regb;
+    adjust_stack(emit, 1);
+}
+
+static void emit_post_push_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc) {
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb);
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc);
+    adjust_stack(emit, 3);
+}
+
+static void emit_post_push_reg_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc, int regd) {
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb);
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc);
+    asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 3, regd);
+    adjust_stack(emit, 4);
+}
+
+static void emit_get_stack_pointer_to_reg_for_pop(emitter_t *emit, int reg_dest, int n_pop) {
+    asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1);
+    adjust_stack(emit, -n_pop);
+}
+
+static void emit_get_stack_pointer_to_reg_for_push(emitter_t *emit, int reg_dest, int n_push) {
+    asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size + n_push - 1);
+    adjust_stack(emit, n_push);
+}
+
+static void emit_call(emitter_t *emit, rt_fun_kind_t fun_kind) {
+    asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
+}
+
+static void emit_call_with_i32_arg(emitter_t *emit, rt_fun_kind_t fun_kind, int32_t arg_val, int arg_reg) {
+    asm_thumb_mov_reg_i32_optimised(emit->as, arg_reg, arg_val);
+    asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
+}
+
+int emit_label_new(emitter_t *emit) {
+    return asm_thumb_label_new(emit->as);
+}
+
+void emit_label_assign(emitter_t *emit, int l) {
+    asm_thumb_label_assign(emit->as, l);
+}
+
+void emit_import_name(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_import_from(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_import_star(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
+    emit_pre(emit);
+    py_obj_t o;
+    switch (tok) {
+        case PY_TOKEN_KW_NONE: o = py_const_none; break;
+        case PY_TOKEN_KW_FALSE: o = py_const_false; break;
+        case PY_TOKEN_KW_TRUE: o = py_const_true; break;
+        default: assert(0); o = 0; // shouldn't happen
+    }
+    emit_post_push_i32(emit, (machine_uint_t)o);
+}
+
+void emit_load_const_small_int(emitter_t *emit, int arg) {
+    emit_pre(emit);
+    if (emit->do_native_types) {
+        emit_post_push_i32(emit, arg);
+    } else {
+        emit_post_push_i32(emit, (arg << 1) | 1);
+    }
+}
+
+void emit_load_const_int(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_const_dec(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_const_id(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) {
+    emit_pre(emit);
+    emit_call_with_i32_arg(emit, RT_F_LOAD_CONST_STR, qstr, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_load_const_verbatim_start(emitter_t *emit) {
+    assert(0);
+}
+void emit_load_const_verbatim_int(emitter_t *emit, int val) {
+    assert(0);
+}
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str) {
+    assert(0);
+}
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) {
+    assert(0);
+}
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) {
+    assert(0);
+}
+void emit_load_const_verbatim_end(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
+    emit_pre(emit);
+    if (local_num == 0) {
+        emit_post_push_reg(emit, REG_LOCAL_1);
+    } else if (local_num == 1) {
+        emit_post_push_reg(emit, REG_LOCAL_2);
+    } else if (local_num == 2) {
+        emit_post_push_reg(emit, REG_LOCAL_3);
+    } else {
+        asm_thumb_mov_reg_local(emit->as, REG_R0, local_num - 1);
+        emit_post_push_reg(emit, REG_R0);
+    }
+}
+
+void emit_load_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit);
+    emit_call_with_i32_arg(emit, RT_F_LOAD_NAME, qstr, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_load_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit);
+    emit_call_with_i32_arg(emit, RT_F_LOAD_GLOBAL, qstr, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_load_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_closure(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_load_attr(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base
+    emit_call_with_i32_arg(emit, RT_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_load_method(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base
+    emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
+    emit_call_with_i32_arg(emit, RT_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name
+}
+
+void emit_load_build_class(emitter_t *emit) {
+   assert(0);
+} // basically load __build_class__ from builtins
+
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
+    if (local_num == 0) {
+        emit_pre_pop_reg(emit, REG_LOCAL_1);
+    } else if (local_num == 1) {
+        emit_pre_pop_reg(emit, REG_LOCAL_2);
+    } else if (local_num == 2) {
+        emit_pre_pop_reg(emit, REG_LOCAL_3);
+    } else {
+        emit_pre_pop_reg(emit, REG_R0);
+        asm_thumb_mov_local_reg(emit->as, local_num - 1, REG_R0);
+    }
+    emit_post(emit);
+}
+
+void emit_store_name(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_reg(emit, REG_ARG_2);
+    emit_call_with_i32_arg(emit, RT_F_STORE_NAME, qstr, REG_ARG_1); // arg1 = name
+    emit_post(emit);
+}
+
+void emit_store_global(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_store_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_store_attr(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_store_locals(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_store_subscr(emitter_t *emit) {
+    emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store
+    emit_call(emit, RT_F_STORE_SUBSCR);
+}
+
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(0);
+}
+void emit_delete_name(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_global(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_attr(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_subscr(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_dup_top(emitter_t *emit) {
+    emit_pre_pop_reg(emit, REG_R0);
+    emit_post_push_reg_reg(emit, REG_R0, REG_R0);
+}
+
+void emit_dup_top_two(emitter_t *emit) {
+    emit_pre_pop_reg_reg(emit, REG_R0, REG_R1);
+    emit_post_push_reg_reg_reg_reg(emit, REG_R1, REG_R0, REG_R1, REG_R0);
+}
+
+void emit_pop_top(emitter_t *emit) {
+    emit_pre_pop_reg(emit, REG_R0);
+    emit_post(emit);
+}
+
+void emit_rot_two(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_rot_three(emitter_t *emit) {
+    emit_pre_pop_reg_reg_reg(emit, REG_R0, REG_R1, REG_R2);
+    emit_post_push_reg_reg_reg(emit, REG_R0, REG_R2, REG_R1);
+}
+
+void emit_jump(emitter_t *emit, int label) {
+    emit_pre(emit);
+    asm_thumb_b_label(emit->as, label);
+    emit_post(emit);
+}
+
+void emit_pop_jump_if_false(emitter_t *emit, int label) {
+    if (emit->do_native_types) {
+        emit_pre_pop_reg(emit, REG_RET);
+        asm_thumb_cmp_reg_bz_label(emit->as, REG_RET, label);
+        emit_post(emit);
+    } else {
+        emit_pre_pop_reg(emit, REG_ARG_1);
+        emit_call(emit, RT_F_IS_TRUE);
+        asm_thumb_cmp_reg_bz_label(emit->as, REG_RET, label);
+        emit_post(emit);
+    }
+}
+
+void emit_pop_jump_if_true(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_jump_if_true_or_pop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_jump_if_false_or_pop(emitter_t *emit, int label) {
+    assert(0);
+}
+
+void emit_setup_loop(emitter_t *emit, int label) {
+    emit_pre(emit);
+    emit_post(emit);
+}
+
+void emit_break_loop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_continue_loop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_setup_with(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_with_cleanup(emitter_t *emit) {
+    assert(0);
+}
+void emit_setup_except(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_setup_finally(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_end_finally(emitter_t *emit) {
+    assert(0);
+}
+void emit_get_iter(emitter_t *emit) {
+    assert(0);
+} // tos = getiter(tos)
+void emit_for_iter(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_for_iter_end(emitter_t *emit) {
+    assert(0);
+}
+void emit_pop_except(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op) {
+    emit_pre_pop_reg(emit, REG_ARG_2);
+    emit_call_with_i32_arg(emit, RT_F_UNARY_OP, op, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_build_tuple(emitter_t *emit, int n_args) {
+    assert(0);
+}
+
+void emit_build_list(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
+    emit_call_with_i32_arg(emit, RT_F_BUILD_LIST, n_args, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET); // new list
+}
+
+void emit_list_append(emitter_t *emit, int list_index) {
+    assert(0);
+}
+
+void emit_build_map(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_call_with_i32_arg(emit, RT_F_BUILD_MAP, n_args, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET); // new map
+}
+
+void emit_store_map(emitter_t *emit) {
+    emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map
+    emit_call(emit, RT_F_STORE_MAP);
+    emit_post_push_reg(emit, REG_RET); // map
+}
+
+void emit_map_add(emitter_t *emit, int map_index) {
+    assert(0);
+}
+
+void emit_build_set(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
+    emit_call_with_i32_arg(emit, RT_F_BUILD_SET, n_args, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET); // new set
+}
+
+void emit_set_add(emitter_t *emit, int set_index) {
+    assert(0);
+}
+void emit_build_slice(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_unpack_sequence(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) {
+    assert(0);
+}
+
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(n_default_params == 0 && n_dict_params == 0);
+    emit_pre(emit);
+    emit_call_with_i32_arg(emit, RT_F_MAKE_FUNCTION_FROM_ID, scope->unique_code_id, REG_ARG_1);
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(0);
+}
+
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
+    if (n_positional == 0) {
+        emit_pre_pop_reg(emit, REG_ARG_1); // the function
+        emit_call(emit, RT_F_CALL_FUNCTION_0);
+    } else if (n_positional == 1) {
+        emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); // the single argument, the function
+        emit_call(emit, RT_F_CALL_FUNCTION_1);
+    } else if (n_positional == 2) {
+        emit_pre_pop_reg_reg_reg(emit, REG_ARG_3, REG_ARG_2, REG_ARG_1); // the second argument, the first argument, the function
+        emit_call(emit, RT_F_CALL_FUNCTION_2);
+    } else {
+        assert(0);
+    }
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
+    if (n_positional == 0) {
+        emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method
+        emit_call(emit, RT_F_CALL_METHOD_1);
+    } else if (n_positional == 1) {
+        emit_pre_pop_reg_reg_reg(emit, REG_ARG_3, REG_ARG_2, REG_ARG_1); // the first argument, the self object (or NULL), the method
+        emit_call(emit, RT_F_CALL_METHOD_2);
+    } else {
+        assert(0);
+    }
+    emit_post_push_reg(emit, REG_RET);
+}
+
+void emit_pop_block(emitter_t *emit) {
+    emit_pre(emit);
+    emit_post(emit);
+}
+
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op) {
+    if (emit->do_native_types) {
+        emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1);
+        asm_thumb_add_reg_reg_reg(emit->as, REG_RET, REG_ARG_1, REG_ARG_2);
+        emit_post_push_reg(emit, REG_RET);
+    } else {
+        emit_pre_pop_reg_reg(emit, REG_ARG_3, REG_ARG_2);
+        emit_call_with_i32_arg(emit, RT_F_BINARY_OP, op, REG_ARG_1);
+        emit_post_push_reg(emit, REG_RET);
+    }
+}
+
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
+    if (emit->do_native_types) {
+        emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1);
+        asm_thumb_cmp_reg_reg(emit->as, REG_ARG_1, REG_ARG_2);
+        asm_thumb_ite_ge(emit->as);
+        asm_thumb_mov_reg_i8(emit->as, REG_RET, 0); // if r0 >= r1
+        asm_thumb_mov_reg_i8(emit->as, REG_RET, 1); // if r0 < r1
+        emit_post_push_reg(emit, REG_RET);
+    } else {
+        emit_pre_pop_reg_reg(emit, REG_ARG_3, REG_ARG_2);
+        emit_call_with_i32_arg(emit, RT_F_COMPARE_OP, op, REG_ARG_1);
+        emit_post_push_reg(emit, REG_RET);
+    }
+}
+
+void emit_return_value(emitter_t *emit) {
+    emit_pre_pop_reg(emit, REG_RET);
+    emit->last_emit_was_return_value = true;
+    //asm_thumb_call_ind(emit->as, 0, REG_R0); to seg fault for debugging with gdb
+    asm_thumb_exit(emit->as);
+}
+
+void emit_raise_varargs(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_yield_value(emitter_t *emit) {
+    assert(0);
+}
+void emit_yield_from(emitter_t *emit) {
+    assert(0);
+}
+
+#endif // EMIT_DO_THUMB
diff --git a/py/emitx64.c b/py/emitx64.c
new file mode 100644
index 0000000..da4c7e3
--- /dev/null
+++ b/py/emitx64.c
@@ -0,0 +1,680 @@
+/* This code is equivalent to emitx64.c but pre-allocates stack
+ * space and uses mov instead of push/pop instructions to access
+ * the temporary stack.  It runs in similar time, but uses 3*n
+ * more bytes, where n is number of push/pop instructions.
+ *
+ * This code is preferred because it keeps the stack aligned on a
+ * 16 byte boundary.
+ *
+ * Improvements:
+ *  Doesn't call stub functions, does all the work inline.
+ *  Has optimisations for loading i64s to stack.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+#include "asmx64.h"
+
+#ifdef EMIT_DO_X64
+
+#define REG_LOCAL_1 (REG_RBX)
+#define REG_LOCAL_NUM (1)
+
+typedef enum {
+    NEED_TO_PUSH_NOTHING,
+    NEED_TO_PUSH_R64,
+    NEED_TO_PUSH_I64,
+} need_to_push_t;
+
+struct _emitter_t {
+    int pass;
+    int stack_start;
+    int stack_size;
+    bool last_emit_was_return_value;
+    need_to_push_t need_to_push;
+    int last_r64;
+    int64_t last_i64;
+
+    scope_t *scope;
+
+    asm_x64_t *as;
+    bool do_native_types;
+};
+
+emitter_t *emit_new() {
+    emitter_t *emit = m_new(emitter_t, 1);
+    emit->as = asm_x64_new();
+    emit->do_native_types = false;
+    return emit;
+}
+
+void emit_set_native_types(emitter_t *emit, bool do_native_types) {
+    emit->do_native_types = do_native_types;
+}
+
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
+    emit->pass = pass;
+    emit->stack_start = 0;
+    emit->stack_size = 0;
+    emit->last_emit_was_return_value = false;
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+    emit->scope = scope;
+    if (pass == PASS_1) {
+        scope->unique_code_id = rt_get_new_unique_code_id();
+    }
+
+    asm_x64_start_pass(emit->as, pass);
+
+    // entry to function
+    int num_locals = 0;
+    if (pass > PASS_1) {
+        num_locals = scope->num_locals - REG_LOCAL_NUM;
+        if (num_locals < 0) {
+            num_locals = 0;
+        }
+        emit->stack_start = num_locals;
+        num_locals += scope->stack_size;
+    }
+    asm_x64_entry(emit->as, num_locals);
+
+    // initialise locals from parameters
+    for (int i = 0; i < scope->num_params; i++) {
+        if (i == 0) {
+            asm_x64_mov_r64_to_r64(emit->as, REG_ARG_1, REG_LOCAL_1);
+        } else if (i == 1) {
+            asm_x64_mov_r64_to_local(emit->as, REG_ARG_2, i - 1);
+        } else if (i == 2) {
+            asm_x64_mov_r64_to_local(emit->as, REG_ARG_3, i - 1);
+        } else {
+            // TODO not implemented
+            assert(0);
+        }
+    }
+}
+
+void emit_end_pass(emitter_t *emit) {
+    if (!emit->last_emit_was_return_value) {
+        asm_x64_exit(emit->as);
+    }
+    asm_x64_end_pass(emit->as);
+
+    // check stack is back to zero size
+    if (emit->stack_size != 0) {
+        printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
+    }
+
+    if (emit->pass == PASS_3) {
+        py_fun_t f = asm_x64_get_code(emit->as);
+        rt_assign_native_code(emit->scope->unique_code_id, f, asm_x64_get_code_size(emit->as), emit->scope->num_params);
+    }
+}
+
+bool emit_last_emit_was_return_value(emitter_t *emit) {
+    return emit->last_emit_was_return_value;
+}
+
+int emit_get_stack_size(emitter_t *emit) {
+    return emit->stack_size;
+}
+
+void emit_set_stack_size(emitter_t *emit, int size) {
+    emit->stack_size = size;
+}
+
+static void adjust_stack(emitter_t *emit, int stack_size_delta) {
+    emit->stack_size += stack_size_delta;
+    assert(emit->stack_size >= 0);
+    if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) {
+        emit->scope->stack_size = emit->stack_size;
+    }
+}
+
+static void stack_settle(emitter_t *emit) {
+    switch (emit->need_to_push) {
+        case NEED_TO_PUSH_NOTHING:
+            break;
+
+        case NEED_TO_PUSH_R64:
+            asm_x64_mov_r64_to_local(emit->as, emit->last_r64, emit->stack_start + emit->stack_size);
+            adjust_stack(emit, 1);
+            break;
+
+        case NEED_TO_PUSH_I64:
+            asm_x64_mov_i64_to_r64_optimised(emit->as, emit->last_i64, REG_RAX);
+            asm_x64_mov_r64_to_local(emit->as, REG_RAX, emit->stack_start + emit->stack_size);
+            adjust_stack(emit, 1);
+            break;
+    }
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+}
+
+static void emit_pre_raw(emitter_t *emit, int stack_size_delta) {
+    adjust_stack(emit, stack_size_delta);
+    emit->last_emit_was_return_value = false;
+}
+
+static void emit_pre(emitter_t *emit) {
+    stack_settle(emit);
+    emit_pre_raw(emit, 0);
+}
+
+static void emit_pre_pop_r64(emitter_t *emit, int r64) {
+    switch (emit->need_to_push) {
+        case NEED_TO_PUSH_NOTHING:
+            asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64);
+            emit_pre_raw(emit, -1);
+            break;
+
+        case NEED_TO_PUSH_R64:
+            emit_pre_raw(emit, 0);
+            if (emit->last_r64 != r64) {
+                asm_x64_mov_r64_to_r64(emit->as, emit->last_r64, r64);
+            }
+            break;
+
+        case NEED_TO_PUSH_I64:
+            emit_pre_raw(emit, 0);
+            asm_x64_mov_i64_to_r64_optimised(emit->as, emit->last_i64, r64);
+            break;
+    }
+    emit->need_to_push = NEED_TO_PUSH_NOTHING;
+}
+
+static void emit_pre_pop_r64_r64(emitter_t *emit, int r64a, int r64b) {
+    emit_pre_pop_r64(emit, r64a);
+    asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b);
+    adjust_stack(emit, -1);
+}
+
+static void emit_pre_pop_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c) {
+    emit_pre_pop_r64(emit, r64a);
+    asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b);
+    asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 2, r64c);
+    adjust_stack(emit, -2);
+}
+
+static void emit_post(emitter_t *emit) {
+}
+
+static void emit_post_push_r64(emitter_t *emit, int r64) {
+    emit->need_to_push = NEED_TO_PUSH_R64;
+    emit->last_r64 = r64;
+}
+
+static void emit_post_push_i64(emitter_t *emit, int64_t i64) {
+    emit->need_to_push = NEED_TO_PUSH_I64;
+    emit->last_i64 = i64;
+}
+
+static void emit_post_push_r64_r64(emitter_t *emit, int r64a, int r64b) {
+    asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
+    emit->need_to_push = NEED_TO_PUSH_R64;
+    emit->last_r64 = r64b;
+    adjust_stack(emit, 1);
+}
+
+static void emit_post_push_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c) {
+    asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
+    asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1);
+    asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2);
+    adjust_stack(emit, 3);
+}
+
+static void emit_post_push_r64_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c, int r64d) {
+    asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
+    asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1);
+    asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2);
+    asm_x64_mov_r64_to_local(emit->as, r64d, emit->stack_start + emit->stack_size + 3);
+    adjust_stack(emit, 4);
+}
+
+static void emit_get_stack_pointer_to_r64_for_pop(emitter_t *emit, int r64, int n_pop) {
+    asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64);
+    adjust_stack(emit, -n_pop);
+}
+
+static void emit_get_stack_pointer_to_r64_for_push(emitter_t *emit, int r64, int n_push) {
+    asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size + n_push - 1, r64);
+    adjust_stack(emit, n_push);
+}
+
+static void emit_call(emitter_t *emit, void *fun) {
+    asm_x64_call_ind(emit->as, fun, REG_RAX);
+}
+
+static void emit_call_with_i64_arg(emitter_t *emit, void *fun, int64_t arg_val, int arg_r64) {
+    asm_x64_mov_i64_to_r64_optimised(emit->as, arg_val, arg_r64);
+    asm_x64_call_ind(emit->as, fun, REG_RAX);
+}
+
+int emit_label_new(emitter_t *emit) {
+    return asm_x64_label_new(emit->as);
+}
+
+void emit_label_assign(emitter_t *emit, int l) {
+    asm_x64_label_assign(emit->as, l);
+}
+
+void emit_import_name(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_import_from(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_import_star(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
+    emit_pre(emit);
+    py_obj_t o;
+    switch (tok) {
+        case PY_TOKEN_KW_NONE: o = py_const_none; break;
+        case PY_TOKEN_KW_FALSE: o = py_const_false; break;
+        case PY_TOKEN_KW_TRUE: o = py_const_true; break;
+        default: assert(0); // shouldn't happen
+    }
+    emit_post_push_i64(emit, (uint64_t)o);
+}
+
+void emit_load_const_small_int(emitter_t *emit, int arg) {
+    emit_pre(emit);
+    if (emit->do_native_types) {
+        emit_post_push_i64(emit, arg);
+    } else {
+        emit_post_push_i64(emit, (arg << 1) | 1);
+    }
+}
+
+void emit_load_const_int(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_const_dec(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_const_id(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) {
+    emit_pre(emit);
+    emit_call_with_i64_arg(emit, rt_load_const_str, qstr, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_load_const_verbatim_start(emitter_t *emit) {
+    assert(0);
+}
+void emit_load_const_verbatim_int(emitter_t *emit, int val) {
+    assert(0);
+}
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str) {
+    assert(0);
+}
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) {
+    assert(0);
+}
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) {
+    assert(0);
+}
+void emit_load_const_verbatim_end(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
+    if (local_num == 0) {
+        emit_pre(emit);
+        emit_post_push_r64(emit, REG_LOCAL_1);
+    } else {
+        emit_pre(emit);
+        asm_x64_mov_local_to_r64(emit->as, local_num - 1, REG_RAX);
+        emit_post_push_r64(emit, REG_RAX);
+    }
+}
+
+void emit_load_name(emitter_t *emit, qstr qstr) {
+    emit_pre(emit);
+    emit_call_with_i64_arg(emit, rt_load_name, qstr, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_load_global(emitter_t *emit, qstr qstr) {
+    emit_pre(emit);
+    emit_call_with_i64_arg(emit, rt_load_global, qstr, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_load_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_load_closure(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_load_attr(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base
+    emit_call_with_i64_arg(emit, rt_load_attr, qstr, REG_ARG_2); // arg2 = attribute name
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_load_method(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base
+    emit_get_stack_pointer_to_r64_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
+    emit_call_with_i64_arg(emit, rt_load_method, qstr, REG_ARG_2); // arg2 = method name
+}
+
+void emit_load_build_class(emitter_t *emit) {
+   assert(0);
+} // basically load __build_class__ from builtins
+
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
+    if (local_num == 0) {
+        emit_pre_pop_r64(emit, REG_LOCAL_1);
+        emit_post(emit);
+    } else {
+        emit_pre_pop_r64(emit, REG_RAX);
+        asm_x64_mov_r64_to_local(emit->as, REG_RAX, local_num - 1);
+        emit_post(emit);
+    }
+}
+
+void emit_store_name(emitter_t *emit, qstr qstr) {
+    emit_pre_pop_r64(emit, REG_ARG_2);
+    emit_call_with_i64_arg(emit, rt_store_name, qstr, REG_ARG_1); // arg1 = name
+    emit_post(emit);
+}
+
+void emit_store_global(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+
+void emit_store_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_store_attr(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_store_locals(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_store_subscr(emitter_t *emit) {
+    emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store
+    emit_call(emit, rt_store_subscr);
+}
+
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(0);
+}
+void emit_delete_name(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_global(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_deref(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_attr(emitter_t *emit, qstr qstr) {
+    assert(0);
+}
+void emit_delete_subscr(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_dup_top(emitter_t *emit) {
+    emit_pre_pop_r64(emit, REG_RAX);
+    emit_post_push_r64_r64(emit, REG_RAX, REG_RAX);
+}
+
+void emit_dup_top_two(emitter_t *emit) {
+    emit_pre_pop_r64_r64(emit, REG_RAX, REG_RDI);
+    emit_post_push_r64_r64_r64_r64(emit, REG_RDI, REG_RAX, REG_RDI, REG_RAX);
+}
+
+void emit_pop_top(emitter_t *emit) {
+    emit_pre_pop_r64(emit, REG_RAX);
+    emit_post(emit);
+}
+
+void emit_rot_two(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_rot_three(emitter_t *emit) {
+    emit_pre_pop_r64_r64_r64(emit, REG_RAX, REG_RDI, REG_RSI);
+    emit_post_push_r64_r64_r64(emit, REG_RAX, REG_RSI, REG_RDI);
+}
+
+void emit_jump(emitter_t *emit, int label) {
+    emit_pre(emit);
+    asm_x64_jmp_label(emit->as, label);
+    emit_post(emit);
+}
+
+void emit_pop_jump_if_false(emitter_t *emit, int label) {
+    if (emit->do_native_types) {
+        emit_pre_pop_r64(emit, REG_RET);
+        asm_x64_test_r8_with_r8(emit->as, REG_RET, REG_RET);
+        asm_x64_jcc_label(emit->as, JCC_JZ, label);
+        emit_post(emit);
+    } else {
+        emit_pre_pop_r64(emit, REG_ARG_1);
+        emit_call(emit, rt_is_true);
+        asm_x64_test_r8_with_r8(emit->as, REG_RET, REG_RET);
+        asm_x64_jcc_label(emit->as, JCC_JZ, label);
+        emit_post(emit);
+    }
+}
+
+void emit_pop_jump_if_true(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_jump_if_true_or_pop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_jump_if_false_or_pop(emitter_t *emit, int label) {
+    assert(0);
+}
+
+void emit_setup_loop(emitter_t *emit, int label) {
+    emit_pre(emit);
+    emit_post(emit);
+}
+
+void emit_break_loop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_continue_loop(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_setup_with(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_with_cleanup(emitter_t *emit) {
+    assert(0);
+}
+void emit_setup_except(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_setup_finally(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_end_finally(emitter_t *emit) {
+    assert(0);
+}
+void emit_get_iter(emitter_t *emit) {
+    assert(0);
+} // tos = getiter(tos)
+void emit_for_iter(emitter_t *emit, int label) {
+    assert(0);
+}
+void emit_for_iter_end(emitter_t *emit) {
+    assert(0);
+}
+void emit_pop_except(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op) {
+    emit_pre_pop_r64(emit, REG_ARG_2);
+    emit_call_with_i64_arg(emit, rt_unary_op, op, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_build_tuple(emitter_t *emit, int n_args) {
+    assert(0);
+}
+
+void emit_build_list(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
+    emit_call_with_i64_arg(emit, rt_build_list, n_args, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET); // new list
+}
+
+void emit_list_append(emitter_t *emit, int list_index) {
+    assert(0);
+}
+
+void emit_build_map(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_call_with_i64_arg(emit, rt_build_map, n_args, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET); // new map
+}
+
+void emit_store_map(emitter_t *emit) {
+    emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map
+    emit_call(emit, rt_store_map);
+    emit_post_push_r64(emit, REG_RET); // map
+}
+
+void emit_map_add(emitter_t *emit, int map_index) {
+    assert(0);
+}
+
+void emit_build_set(emitter_t *emit, int n_args) {
+    emit_pre(emit);
+    emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
+    emit_call_with_i64_arg(emit, rt_build_set, n_args, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET); // new set
+}
+
+void emit_set_add(emitter_t *emit, int set_index) {
+    assert(0);
+}
+void emit_build_slice(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_unpack_sequence(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) {
+    assert(0);
+}
+
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(n_default_params == 0 && n_dict_params == 0);
+    emit_pre(emit);
+    emit_call_with_i64_arg(emit, rt_make_function_from_id, scope->unique_code_id, REG_ARG_1);
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    assert(0);
+}
+
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
+    if (n_positional == 0) {
+        emit_pre_pop_r64(emit, REG_ARG_1); // the function
+        emit_call(emit, rt_call_function_0);
+    } else if (n_positional == 1) {
+        emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_ARG_1); // the single argument, the function
+        emit_call(emit, rt_call_function_1);
+    } else if (n_positional == 2) {
+        emit_pre_pop_r64_r64_r64(emit, REG_ARG_3, REG_ARG_2, REG_ARG_1); // the second argument, the first argument, the function
+        emit_call(emit, rt_call_function_2);
+    } else {
+        assert(0);
+    }
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
+    assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
+    if (n_positional == 0) {
+        emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method
+        emit_call(emit, rt_call_method_1);
+    } else if (n_positional == 1) {
+        emit_pre_pop_r64_r64_r64(emit, REG_ARG_3, REG_ARG_2, REG_ARG_1); // the first argument, the self object (or NULL), the method
+        emit_call(emit, rt_call_method_2);
+    } else {
+        assert(0);
+    }
+    emit_post_push_r64(emit, REG_RET);
+}
+
+void emit_pop_block(emitter_t *emit) {
+    emit_pre(emit);
+    emit_post(emit);
+}
+
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op) {
+    if (emit->do_native_types) {
+        assert(op == RT_BINARY_OP_ADD);
+        emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_RET);
+        asm_x64_add_r64_to_r64(emit->as, REG_ARG_2, REG_RET);
+        emit_post_push_r64(emit, REG_RET);
+    } else {
+        emit_pre_pop_r64_r64(emit, REG_ARG_3, REG_ARG_2);
+        emit_call_with_i64_arg(emit, rt_binary_op, op, REG_ARG_1);
+        emit_post_push_r64(emit, REG_RET);
+    }
+}
+
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
+    if (emit->do_native_types) {
+        assert(op == RT_COMPARE_OP_LESS);
+        emit_pre_pop_r64_r64(emit, REG_ARG_3, REG_ARG_2);
+        asm_x64_xor_r64_to_r64(emit->as, REG_RET, REG_RET);
+        asm_x64_cmp_r64_with_r64(emit->as, REG_ARG_3, REG_ARG_2);
+        asm_x64_setcc_r8(emit->as, JCC_JL, REG_RET);
+        emit_post_push_r64(emit, REG_RET);
+    } else {
+        emit_pre_pop_r64_r64(emit, REG_ARG_3, REG_ARG_2);
+        emit_call_with_i64_arg(emit, rt_compare_op, op, REG_ARG_1);
+        emit_post_push_r64(emit, REG_RET);
+    }
+}
+
+void emit_return_value(emitter_t *emit) {
+    emit_pre_pop_r64(emit, REG_RAX);
+    emit->last_emit_was_return_value = true;
+    //asm_x64_call_ind(emit->as, 0, REG_RAX); to seg fault for debugging with gdb
+    asm_x64_exit(emit->as);
+}
+
+void emit_raise_varargs(emitter_t *emit, int n_args) {
+    assert(0);
+}
+void emit_yield_value(emitter_t *emit) {
+    assert(0);
+}
+void emit_yield_from(emitter_t *emit) {
+    assert(0);
+}
+
+#endif // EMIT_DO_X64
diff --git a/py/grammar.h b/py/grammar.h
new file mode 100644
index 0000000..05bb237
--- /dev/null
+++ b/py/grammar.h
@@ -0,0 +1,300 @@
+// rules for writing rules:
+// - zero_or_more is implemented using opt_rule around a one_or_more rule
+// - don't put opt_rule in arguments of or rule; instead, wrap the call to this or rule in opt_rule
+
+// # Start symbols for the grammar:
+// #       single_input is a single interactive statement;
+// #       file_input is a module or sequence of commands read from an input file;
+// #       eval_input is the input for the eval() functions.
+// # NB: compound_stmt in single_input is followed by extra NEWLINE!
+// single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
+// file_input: (NEWLINE | stmt)* ENDMARKER
+// eval_input: testlist NEWLINE* ENDMARKER
+
+DEF_RULE(file_input, nc, and(1), opt_rule(file_input_2))
+DEF_RULE(file_input_2, c(generic_all_nodes), one_or_more, rule(file_input_3))
+DEF_RULE(file_input_3, nc, or(2), tok(NEWLINE), rule(stmt))
+
+// decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+// decorators: decorator+
+// decorated: decorators (classdef | funcdef)
+// funcdef: 'def' NAME parameters ['->' test] ':' suite
+// parameters: '(' [typedargslist] ')'
+// typedargslist: tfpdef ['=' test] (',' tfpdef ['=' test])* [',' ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]] | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef
+// tfpdef: NAME [':' test]
+// varargslist: vfpdef ['=' test] (',' vfpdef ['=' test])* [',' ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] |  '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef
+// vfpdef: NAME
+
+DEF_RULE(decorator, nc, and(4), tok(DEL_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
+//DEF_RULE(decorator_2, nc, and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
+DEF_RULE(decorators, nc, one_or_more, rule(decorator))
+DEF_RULE(decorated, c(decorated), and(2), rule(decorators), rule(decorated_body))
+DEF_RULE(decorated_body, nc, or(2), rule(classdef), rule(funcdef))
+DEF_RULE(funcdef, c(funcdef), and(8), tok(KW_DEF), tok(NAME), tok(DEL_PAREN_OPEN), opt_rule(typedargslist), tok(DEL_PAREN_CLOSE), opt_rule(funcdef_2), tok(DEL_COLON), rule(suite))
+DEF_RULE(funcdef_2, nc, and(2), tok(DEL_MINUS_MORE), rule(test))
+// TODO typedargslist lets through more than is allowed
+DEF_RULE(typedargslist, nc, list_with_end, rule(typedargslist_item), tok(DEL_COMMA))
+DEF_RULE(typedargslist_item, nc, or(3), rule(typedargslist_name), rule(typedargslist_star), rule(typedargslist_dbl_star))
+DEF_RULE(typedargslist_name, nc, and(3), tok(NAME), opt_rule(typedargslist_colon), opt_rule(typedargslist_equal))
+DEF_RULE(typedargslist_star, nc, and(2), tok(OP_STAR), opt_rule(tfpdef))
+DEF_RULE(typedargslist_dbl_star, nc, and(3), tok(OP_DBL_STAR), tok(NAME), opt_rule(typedargslist_colon))
+DEF_RULE(typedargslist_colon, nc, and(2), tok(DEL_COLON), rule(test))
+DEF_RULE(typedargslist_equal, nc, and(2), tok(DEL_EQUAL), rule(test))
+DEF_RULE(tfpdef, nc, and(2), tok(NAME), opt_rule(typedargslist_colon))
+// TODO varargslist lets through more than is allowed
+DEF_RULE(varargslist, nc, list_with_end, rule(varargslist_item), tok(DEL_COMMA))
+DEF_RULE(varargslist_item, nc, or(3), rule(varargslist_name), rule(varargslist_star), rule(varargslist_dbl_star))
+DEF_RULE(varargslist_name, nc, and(2), tok(NAME), opt_rule(varargslist_equal))
+DEF_RULE(varargslist_star, nc, and(2), tok(OP_STAR), opt_rule(vfpdef))
+DEF_RULE(varargslist_dbl_star, nc, and(2), tok(OP_DBL_STAR), tok(NAME))
+DEF_RULE(varargslist_equal, nc, and(2), tok(DEL_EQUAL), rule(test))
+DEF_RULE(vfpdef, nc, and(1), tok(NAME))
+
+// stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | simple_stmt
+
+DEF_RULE(stmt, nc, or(9), rule(if_stmt), rule(while_stmt), rule(for_stmt), rule(try_stmt), rule(with_stmt), rule(funcdef), rule(classdef), rule(decorated), rule(simple_stmt))
+
+// simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+
+DEF_RULE(simple_stmt, nc, and(2), rule(simple_stmt_2), tok(NEWLINE))
+DEF_RULE(simple_stmt_2, c(generic_all_nodes), list_with_end, rule(small_stmt), tok(DEL_SEMICOLON))
+
+// small_stmt: expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt
+// expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))*)
+// testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
+// augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
+// # For normal assignments, additional restrictions enforced by the interpreter
+
+DEF_RULE(small_stmt, nc, or(8), rule(del_stmt), rule(pass_stmt), rule(flow_stmt), rule(import_stmt), rule(global_stmt), rule(nonlocal_stmt), rule(assert_stmt), rule(expr_stmt))
+DEF_RULE(expr_stmt, c(expr_stmt), and(2), rule(testlist_star_expr), opt_rule(expr_stmt_2))
+DEF_RULE(expr_stmt_2, nc, or(2), rule(expr_stmt_augassign), rule(expr_stmt_assign_list))
+DEF_RULE(expr_stmt_augassign, nc, and(2), rule(augassign), rule(expr_stmt_6))
+DEF_RULE(expr_stmt_assign_list, nc, one_or_more, rule(expr_stmt_assign))
+DEF_RULE(expr_stmt_assign, nc, and(2), tok(DEL_EQUAL), rule(expr_stmt_6))
+DEF_RULE(expr_stmt_6, nc, or(2), rule(yield_expr), rule(testlist_star_expr))
+DEF_RULE(testlist_star_expr, c(generic_tuple), list_with_end, rule(testlist_star_expr_2), tok(DEL_COMMA))
+DEF_RULE(testlist_star_expr_2, nc, or(2), rule(star_expr), rule(test))
+DEF_RULE(augassign, nc, or(12), tok(DEL_PLUS_EQUAL), tok(DEL_MINUS_EQUAL), tok(DEL_STAR_EQUAL), tok(DEL_SLASH_EQUAL), tok(DEL_PERCENT_EQUAL), tok(DEL_AMPERSAND_EQUAL), tok(DEL_PIPE_EQUAL), tok(DEL_CARET_EQUAL), tok(DEL_DBL_LESS_EQUAL), tok(DEL_DBL_MORE_EQUAL), tok(DEL_DBL_STAR_EQUAL), tok(DEL_DBL_SLASH_EQUAL))
+
+// del_stmt: 'del' exprlist
+// pass_stmt: 'pass'
+// flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+// break_stmt: 'break'
+// continue_stmt: 'continue'
+// return_stmt: 'return' [testlist]
+// yield_stmt: yield_expr
+// raise_stmt: 'raise' [test ['from' test]]
+
+DEF_RULE(del_stmt, c(del_stmt), and(2), tok(KW_DEL), rule(exprlist))
+DEF_RULE(pass_stmt, c(generic_all_nodes), and(1), tok(KW_PASS))
+DEF_RULE(flow_stmt, nc, or(5), rule(break_stmt), rule(continue_stmt), rule(return_stmt), rule(raise_stmt), rule(yield_stmt))
+DEF_RULE(break_stmt, c(break_stmt), and(1), tok(KW_BREAK))
+DEF_RULE(continue_stmt, c(continue_stmt), and(1), tok(KW_CONTINUE))
+DEF_RULE(return_stmt, c(return_stmt), and(2), tok(KW_RETURN), opt_rule(testlist))
+DEF_RULE(yield_stmt, c(yield_stmt), and(1), rule(yield_expr))
+DEF_RULE(raise_stmt, c(raise_stmt), and(2), tok(KW_RAISE), opt_rule(raise_stmt_arg))
+DEF_RULE(raise_stmt_arg, nc, and(2), rule(test), opt_rule(raise_stmt_from))
+DEF_RULE(raise_stmt_from, nc, and(2), tok(KW_FROM), rule(test))
+
+// import_stmt: import_name | import_from
+// import_name: 'import' dotted_as_names
+// import_from: 'from' (('.' | '...')* dotted_name | ('.' | '...')+) 'import' ('*' | '(' import_as_names ')' | import_as_names)
+// import_as_name: NAME ['as' NAME]
+// dotted_as_name: dotted_name ['as' NAME]
+// import_as_names: import_as_name (',' import_as_name)* [',']
+// dotted_as_names: dotted_as_name (',' dotted_as_name)*
+// dotted_name: NAME ('.' NAME)*
+// global_stmt: 'global' NAME (',' NAME)*
+// nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
+// assert_stmt: 'assert' test [',' test]
+
+DEF_RULE(import_stmt, nc, or(2), rule(import_name), rule(import_from))
+DEF_RULE(import_name, c(import_name), and(2), tok(KW_IMPORT), rule(dotted_as_names))
+DEF_RULE(import_from, c(import_from), and(4), tok(KW_FROM), rule(import_from_2), tok(KW_IMPORT), rule(import_from_3))
+DEF_RULE(import_from_2, nc, or(2), rule(dotted_name), rule(import_from_2b))
+DEF_RULE(import_from_2b, nc, and(2), rule(one_or_more_period_or_ellipses), opt_rule(dotted_name))
+DEF_RULE(import_from_3, nc, or(3), tok(OP_STAR), rule(import_as_names_paren), rule(import_as_names))
+DEF_RULE(import_as_names_paren, nc, and(3), tok(DEL_PAREN_OPEN), rule(import_as_names), tok(DEL_PAREN_CLOSE))
+DEF_RULE(one_or_more_period_or_ellipses, nc, one_or_more, rule(period_or_ellipses))
+DEF_RULE(period_or_ellipses, nc, or(2), tok(DEL_PERIOD), tok(ELLIPSES))
+DEF_RULE(import_as_name, nc, and(2), tok(NAME), opt_rule(as_name))
+DEF_RULE(dotted_as_name, nc, and(2), rule(dotted_name), opt_rule(as_name))
+DEF_RULE(as_name, nc, and(2), tok(KW_AS), tok(NAME))
+DEF_RULE(import_as_names, nc, list_with_end, rule(import_as_name), tok(DEL_COMMA))
+DEF_RULE(dotted_as_names, nc, list, rule(dotted_as_name), tok(DEL_COMMA))
+DEF_RULE(dotted_name, nc, list, tok(NAME), tok(DEL_PERIOD))
+DEF_RULE(global_stmt, c(global_stmt), and(2), tok(KW_GLOBAL), rule(name_list))
+DEF_RULE(nonlocal_stmt, c(nonlocal_stmt), and(2), tok(KW_NONLOCAL), rule(name_list))
+DEF_RULE(name_list, nc, list, tok(NAME), tok(DEL_COMMA))
+DEF_RULE(assert_stmt, c(assert_stmt), and(3), tok(KW_ASSERT), rule(test), opt_rule(assert_stmt_extra))
+DEF_RULE(assert_stmt_extra, nc, and(2), tok(DEL_COMMA), rule(test))
+
+// if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+// while_stmt: 'while' test ':' suite ['else' ':' suite]
+// for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+// try_stmt: 'try' ':' suite ((except_clause ':' suite)+ ['else' ':' suite] ['finally' ':' suite] | 'finally' ':' suite)
+// # NB compile.c makes sure that the default except clause is last
+// except_clause: 'except' [test ['as' NAME]]
+// with_stmt: 'with' with_item (',' with_item)* ':' suite
+// with_item: test ['as' expr]
+// suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+
+DEF_RULE(if_stmt, c(if_stmt), and(6), tok(KW_IF), rule(test), tok(DEL_COLON), rule(suite), opt_rule(if_stmt_elif_list), opt_rule(else_stmt))
+DEF_RULE(if_stmt_elif_list, nc, one_or_more, rule(if_stmt_elif))
+DEF_RULE(if_stmt_elif, nc, and(4), tok(KW_ELIF), rule(test), tok(DEL_COLON), rule(suite))
+DEF_RULE(while_stmt, c(while_stmt), and(5), tok(KW_WHILE), rule(test), tok(DEL_COLON), rule(suite), opt_rule(else_stmt))
+DEF_RULE(for_stmt, c(for_stmt), and(7), tok(KW_FOR), rule(exprlist), tok(KW_IN), rule(testlist), tok(DEL_COLON), rule(suite), opt_rule(else_stmt))
+DEF_RULE(try_stmt, c(try_stmt), and(4), tok(KW_TRY), tok(DEL_COLON), rule(suite), rule(try_stmt_2))
+DEF_RULE(try_stmt_2, nc, or(2), rule(try_stmt_except_and_more), rule(try_stmt_finally))
+DEF_RULE(try_stmt_except_and_more, nc, and(3), rule(try_stmt_except_list), opt_rule(else_stmt), opt_rule(try_stmt_finally))
+DEF_RULE(try_stmt_except, nc, and(4), tok(KW_EXCEPT), opt_rule(try_stmt_as_name), tok(DEL_COLON), rule(suite))
+DEF_RULE(try_stmt_as_name, nc, and(2), rule(test), opt_rule(as_name))
+DEF_RULE(try_stmt_except_list, nc, one_or_more, rule(try_stmt_except))
+DEF_RULE(try_stmt_finally, nc, and(3), tok(KW_FINALLY), tok(DEL_COLON), rule(suite))
+DEF_RULE(else_stmt, nc, and(3), tok(KW_ELSE), tok(DEL_COLON), rule(suite))
+DEF_RULE(with_stmt, c(with_stmt), and(4), tok(KW_WITH), rule(with_stmt_list), tok(DEL_COLON), rule(suite))
+DEF_RULE(with_stmt_list, nc, list, rule(with_item), tok(DEL_COMMA))
+DEF_RULE(with_item, nc, and(2), rule(test), opt_rule(with_item_as))
+DEF_RULE(with_item_as, nc, and(2), tok(KW_AS), rule(expr))
+DEF_RULE(suite, nc, or(2), rule(suite_block), rule(simple_stmt))
+DEF_RULE(suite_block, nc, and(4), tok(NEWLINE), tok(INDENT), rule(suite_block_stmts), tok(DEDENT))
+DEF_RULE(suite_block_stmts, c(generic_all_nodes), one_or_more, rule(stmt))
+
+// test: or_test ['if' or_test 'else' test] | lambdef
+// test_nocond: or_test | lambdef_nocond
+// lambdef: 'lambda' [varargslist] ':' test
+// lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
+
+DEF_RULE(test, nc, or(2), rule(lambdef), rule(test_if_expr))
+DEF_RULE(test_if_expr, c(test_if_expr), and(2), rule(or_test), opt_rule(test_if_else))
+DEF_RULE(test_if_else, nc, and(4), tok(KW_IF), rule(or_test), tok(KW_ELSE), rule(test))
+DEF_RULE(test_nocond, nc, or(2), rule(lambdef_nocond), rule(or_test))
+DEF_RULE(lambdef, c(lambdef), and(4), tok(KW_LAMBDA), opt_rule(varargslist), tok(DEL_COLON), rule(test))
+DEF_RULE(lambdef_nocond, c(lambdef), and(4), tok(KW_LAMBDA), opt_rule(varargslist), tok(DEL_COLON), rule(test_nocond))
+
+// or_test: and_test ('or' and_test)*
+// and_test: not_test ('and' not_test)*
+// not_test: 'not' not_test | comparison
+// comparison: expr (comp_op expr)*
+// comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'in'|'not' 'in'|'is'|'is' 'not'
+// star_expr: '*' expr
+// expr: xor_expr ('|' xor_expr)*
+// xor_expr: and_expr ('^' and_expr)*
+// and_expr: shift_expr ('&' shift_expr)*
+// shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+// arith_expr: term (('+'|'-') term)*
+// term: factor (('*'|'/'|'%'|'//') factor)*
+// factor: ('+'|'-'|'~') factor | power
+// power: atom trailer* ['**' factor]
+
+DEF_RULE(or_test, c(or_test), list, rule(and_test), tok(KW_OR))
+DEF_RULE(and_test, c(and_test), list, rule(not_test), tok(KW_AND))
+DEF_RULE(not_test, nc, or(2), rule(not_test_2), rule(comparison))
+DEF_RULE(not_test_2, c(not_test_2), and(2), tok(KW_NOT), rule(not_test))
+DEF_RULE(comparison, c(comparison), list, rule(expr), rule(comp_op))
+DEF_RULE(comp_op, nc, or(9), tok(OP_LESS), tok(OP_MORE), tok(OP_DBL_EQUAL), tok(OP_LESS_EQUAL), tok(OP_MORE_EQUAL), tok(OP_NOT_EQUAL), tok(KW_IN), rule(comp_op_not_in), rule(comp_op_is))
+DEF_RULE(comp_op_not_in, nc, and(2), tok(KW_NOT), tok(KW_IN))
+DEF_RULE(comp_op_is, nc, and(2), tok(KW_IS), opt_rule(comp_op_is_not))
+DEF_RULE(comp_op_is_not, nc, and(1), tok(KW_NOT))
+DEF_RULE(star_expr, c(star_expr), and(2), tok(OP_STAR), rule(expr))
+DEF_RULE(expr, c(expr), list, rule(xor_expr), tok(OP_PIPE))
+DEF_RULE(xor_expr, c(xor_expr), list, rule(and_expr), tok(OP_CARET))
+DEF_RULE(and_expr, c(and_expr), list, rule(shift_expr), tok(OP_AMPERSAND))
+DEF_RULE(shift_expr, c(shift_expr), list, rule(arith_expr), rule(shift_op))
+DEF_RULE(shift_op, nc, or(2), tok(OP_DBL_LESS), tok(OP_DBL_MORE))
+DEF_RULE(arith_expr, c(arith_expr), list, rule(term), rule(arith_op))
+DEF_RULE(arith_op, nc, or(2), tok(OP_PLUS), tok(OP_MINUS))
+DEF_RULE(term, c(term), list, rule(factor), rule(term_op))
+DEF_RULE(term_op, nc, or(4), tok(OP_STAR), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
+DEF_RULE(factor, nc, or(2), rule(factor_2), rule(power))
+DEF_RULE(factor_2, c(factor_2), and(2), rule(factor_op), rule(factor))
+DEF_RULE(factor_op, nc, or(3), tok(OP_PLUS), tok(OP_MINUS), tok(OP_TILDE))
+DEF_RULE(power, c(generic_all_nodes), and(3), rule(atom), opt_rule(power_trailers), opt_rule(power_dbl_star))
+DEF_RULE(power_trailers, c(power_trailers), one_or_more, rule(trailer))
+DEF_RULE(power_dbl_star, c(power_dbl_star), and(2), tok(OP_DBL_STAR), rule(factor))
+
+// atom: '(' [yield_expr|testlist_comp] ')' | '[' [testlist_comp] ']' | '{' [dictorsetmaker] '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False'
+// testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
+// trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+
+DEF_RULE(atom, nc, or(10), tok(NAME), tok(NUMBER), rule(atom_string), tok(ELLIPSES), tok(KW_NONE), tok(KW_TRUE), tok(KW_FALSE), rule(atom_paren), rule(atom_bracket), rule(atom_brace))
+DEF_RULE(atom_string, c(atom_string), one_or_more, rule(string_or_bytes))
+DEF_RULE(string_or_bytes, nc, or(2), tok(STRING), tok(BYTES))
+DEF_RULE(atom_paren, c(atom_paren), and(3), tok(DEL_PAREN_OPEN), opt_rule(atom_2b), tok(DEL_PAREN_CLOSE))
+DEF_RULE(atom_2b, nc, or(2), rule(yield_expr), rule(testlist_comp))
+DEF_RULE(atom_bracket, c(atom_bracket), and(3), tok(DEL_BRACKET_OPEN), opt_rule(testlist_comp), tok(DEL_BRACKET_CLOSE))
+DEF_RULE(atom_brace, c(atom_brace), and(3), tok(DEL_BRACE_OPEN), opt_rule(dictorsetmaker), tok(DEL_BRACE_CLOSE))
+DEF_RULE(testlist_comp, nc, and(2), rule(testlist_comp_2), opt_rule(testlist_comp_3))
+DEF_RULE(testlist_comp_2, nc, or(2), rule(star_expr), rule(test))
+DEF_RULE(testlist_comp_3, nc, or(2), rule(comp_for), rule(testlist_comp_3b))
+DEF_RULE(testlist_comp_3b, nc, and(2), tok(DEL_COMMA), opt_rule(testlist_comp_3c))
+DEF_RULE(testlist_comp_3c, nc, list_with_end, rule(testlist_comp_2), tok(DEL_COMMA))
+DEF_RULE(trailer, nc, or(3), rule(trailer_paren), rule(trailer_bracket), rule(trailer_period))
+DEF_RULE(trailer_paren, c(trailer_paren), and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
+DEF_RULE(trailer_bracket, c(trailer_bracket), and(3), tok(DEL_BRACKET_OPEN), rule(subscriptlist), tok(DEL_BRACKET_CLOSE))
+DEF_RULE(trailer_period, c(trailer_period), and(2), tok(DEL_PERIOD), tok(NAME))
+
+// subscriptlist: subscript (',' subscript)* [',']
+// subscript: test | [test] ':' [test] [sliceop]
+// sliceop: ':' [test]
+
+DEF_RULE(subscriptlist, c(generic_tuple), list_with_end, rule(subscript), tok(DEL_COMMA))
+DEF_RULE(subscript, nc, or(2), rule(subscript_3), rule(subscript_2))
+DEF_RULE(subscript_2, c(subscript_2), and(2), rule(test), opt_rule(subscript_3))
+DEF_RULE(subscript_3, c(subscript_3), and(2), tok(DEL_COLON), opt_rule(subscript_3b))
+DEF_RULE(subscript_3b, nc, or(2), rule(subscript_3c), rule(subscript_3d))
+DEF_RULE(subscript_3c, nc, and(2), tok(DEL_COLON), opt_rule(test))
+DEF_RULE(subscript_3d, nc, and(2), rule(test), opt_rule(sliceop))
+DEF_RULE(sliceop, nc, and(2), tok(DEL_COLON), opt_rule(test))
+
+// exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']
+// testlist: test (',' test)* [',']
+// dictorsetmaker: (test ':' test (comp_for | (',' test ':' test)* [','])) | (test (comp_for | (',' test)* [',']))
+
+DEF_RULE(exprlist, nc, list_with_end, rule(exprlist_2), tok(DEL_COMMA))
+DEF_RULE(exprlist_2, nc, or(2), rule(star_expr), rule(expr))
+DEF_RULE(testlist, c(generic_tuple), list_with_end, rule(test), tok(DEL_COMMA))
+// TODO dictorsetmaker lets through more than is allowed
+DEF_RULE(dictorsetmaker, nc, and(2), rule(dictorsetmaker_item), opt_rule(dictorsetmaker_tail))
+DEF_RULE(dictorsetmaker_item, c(dictorsetmaker_item), and(2), rule(test), opt_rule(dictorsetmaker_colon))
+DEF_RULE(dictorsetmaker_colon, nc, and(2), tok(DEL_COLON), rule(test))
+DEF_RULE(dictorsetmaker_tail, nc, or(2), rule(comp_for), rule(dictorsetmaker_list))
+DEF_RULE(dictorsetmaker_list, nc, and(2), tok(DEL_COMMA), opt_rule(dictorsetmaker_list2))
+DEF_RULE(dictorsetmaker_list2, nc, list_with_end, rule(dictorsetmaker_item), tok(DEL_COMMA))
+
+// classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+
+DEF_RULE(classdef, c(classdef), and(5), tok(KW_CLASS), tok(NAME), opt_rule(classdef_2), tok(DEL_COLON), rule(suite))
+DEF_RULE(classdef_2, nc, and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
+
+// arglist: (argument ',')* (argument [','] | '*' test (',' argument)* [',' '**' test] | '**' test)
+
+// TODO arglist lets through more than is allowed, compiler needs to do further verification
+DEF_RULE(arglist, c(generic_all_nodes), list_with_end, rule(arglist_2), tok(DEL_COMMA))
+DEF_RULE(arglist_2, nc, or(3), rule(arglist_star), rule(arglist_dbl_star), rule(argument))
+DEF_RULE(arglist_star, c(arglist_star), and(2), tok(OP_STAR), rule(test))
+DEF_RULE(arglist_dbl_star, c(arglist_dbl_star), and(2), tok(OP_DBL_STAR), rule(test))
+
+// # The reason that keywords are test nodes instead of NAME is that using NAME
+// # results in an ambiguity. ast.c makes sure it's a NAME.
+// argument: test [comp_for] | test '=' test  # Really [keyword '='] test
+// comp_iter: comp_for | comp_if
+// comp_for: 'for' exprlist 'in' or_test [comp_iter]
+// comp_if: 'if' test_nocond [comp_iter]
+
+DEF_RULE(argument, c(argument), and(2), rule(test), opt_rule(argument_2))
+DEF_RULE(argument_2, nc, or(2), rule(comp_for), rule(argument_3))
+DEF_RULE(argument_3, nc, and(2), tok(DEL_EQUAL), rule(test))
+DEF_RULE(comp_iter, nc, or(2), rule(comp_for), rule(comp_if))
+DEF_RULE(comp_for, nc, and(5), tok(KW_FOR), rule(exprlist), tok(KW_IN), rule(or_test), opt_rule(comp_iter))
+DEF_RULE(comp_if, nc, and(3), tok(KW_IF), rule(test_nocond), opt_rule(comp_iter))
+
+// # not used in grammar, but may appear in "node" passed from Parser to Compiler
+// encoding_decl: NAME
+
+// yield_expr: 'yield' [yield_arg]
+// yield_arg: 'from' test | testlist
+
+DEF_RULE(yield_expr, c(yield_expr), and(2), tok(KW_YIELD), opt_rule(yield_arg))
+DEF_RULE(yield_arg, nc, or(2), rule(yield_arg_from), rule(testlist))
+DEF_RULE(yield_arg_from, nc, and(2), tok(KW_FROM), rule(test))
diff --git a/py/lexer.c b/py/lexer.c
new file mode 100644
index 0000000..9c2195e
--- /dev/null
+++ b/py/lexer.c
@@ -0,0 +1,677 @@
+/* lexer.c -- simple tokeniser for Python implementation
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+
+#define TAB_SIZE (8)
+#define CHR_EOF (-1)
+
+struct _py_lexer_t {
+    const char *name;           // (file) name of source
+    bool free;                  // free source when done with it
+
+    const char *src_beg;        // beginning of source
+    const char *src_cur;        // current location in source; points to chr0
+    const char *src_end;        // end (exclusive) of source
+    unichar chr0, chr1, chr2;   // current characters from source
+
+    uint line;                  // source line
+    uint column;                // source column
+
+    uint cont_line;             // continued line
+
+    int emit_dent;
+    int nested_bracket_level;
+
+    uint alloc_indent_level;
+    uint num_indent_level;
+    uint16_t *indent_level;
+
+    py_token_t tok_cur;
+    py_token_t tok_next;
+};
+
+static bool py_token_is_str(const py_token_t *tok, const char *str) {
+    uint i = 0;
+    const char *tstr = tok->str;
+
+    while (i < tok->len && *tstr == *str) {
+        ++i;
+        ++tstr;
+        ++str;
+    }
+
+    return i == tok->len && *str == 0;
+}
+
+void py_token_show(const py_token_t *tok) {
+    printf("(%s:%d:%d) kind:%d cont_line:%d str:%p len:%d", tok->src_name, tok->src_line, tok->src_column, tok->kind, tok->cont_line, tok->str, tok->len);
+    if (tok->str != NULL && tok->len > 0) {
+        const char *i = tok->str;
+        const char *j = i + tok->len;
+        printf(" ");
+        while (i < j) {
+            unichar c = g_utf8_get_char(i);
+            i = g_utf8_next_char(i);
+            if (g_unichar_isprint(c)) {
+                printf("%c", c);
+            } else {
+                printf("?");
+            }
+        }
+    }
+    printf("\n");
+}
+
+void py_token_show_error_prefix(const py_token_t *tok) {
+    printf("(%s:%d:%d) ", tok->src_name, tok->src_line, tok->src_column);
+}
+
+bool py_token_show_error(const py_token_t *tok, const char *msg) {
+    printf("(%s:%d:%d) %s\n", tok->src_name, tok->src_line, tok->src_column, msg);
+    return false;
+}
+
+static bool is_end(py_lexer_t *lex) {
+    return lex->chr0 == CHR_EOF;
+}
+
+static bool is_physical_newline(py_lexer_t *lex) {
+    return lex->chr0 == '\n' || lex->chr0 == '\r';
+}
+
+static bool is_char(py_lexer_t *lex, char c) {
+    return lex->chr0 == c;
+}
+
+static bool is_char_or(py_lexer_t *lex, char c1, char c2) {
+    return lex->chr0 == c1 || lex->chr0 == c2;
+}
+
+static bool is_char_or3(py_lexer_t *lex, char c1, char c2, char c3) {
+    return lex->chr0 == c1 || lex->chr0 == c2 || lex->chr0 == c3;
+}
+
+/*
+static bool is_char_following(py_lexer_t *lex, char c) {
+    return lex->chr1 == c;
+}
+*/
+
+static bool is_char_following_or(py_lexer_t *lex, char c1, char c2) {
+    return lex->chr1 == c1 || lex->chr1 == c2;
+}
+
+static bool is_char_following_following_or(py_lexer_t *lex, char c1, char c2) {
+    return lex->chr2 == c1 || lex->chr2 == c2;
+}
+
+static bool is_char_and(py_lexer_t *lex, char c1, char c2) {
+    return lex->chr0 == c1 && lex->chr1 == c2;
+}
+
+static bool is_whitespace(py_lexer_t *lex) {
+    return g_unichar_isspace(lex->chr0);
+}
+
+static bool is_letter(py_lexer_t *lex) {
+    return g_unichar_isalpha(lex->chr0);
+}
+
+static bool is_digit(py_lexer_t *lex) {
+    return g_unichar_isdigit(lex->chr0);
+}
+
+static bool is_following_digit(py_lexer_t *lex) {
+    return g_unichar_isdigit(lex->chr1);
+}
+
+// TODO UNICODE include unicode characters in definition of identifiers
+static bool is_head_of_identifier(py_lexer_t *lex) {
+    return is_letter(lex) || lex->chr0 == '_';
+}
+
+// TODO UNICODE include unicode characters in definition of identifiers
+static bool is_tail_of_identifier(py_lexer_t *lex) {
+    return is_head_of_identifier(lex) || is_digit(lex);
+}
+
+static void next_char(py_lexer_t *lex) {
+    if (lex->chr0 == CHR_EOF) {
+        return;
+    }
+
+    int advance = 1;
+
+    if (lex->chr0 == '\n') {
+        // LF is a new line
+        ++lex->line;
+        lex->column = 1;
+        lex->cont_line = lex->line;
+    } else if (lex->chr0 == '\r') {
+        // CR is a new line
+        ++lex->line;
+        lex->column = 1;
+        lex->cont_line = lex->line;
+        if (lex->chr1 == '\n') {
+            // CR LF is a single new line
+            advance = 2;
+        }
+    } else if (lex->chr0 == '\t') {
+        // a tab
+        lex->column = (((lex->column - 1 + TAB_SIZE) / TAB_SIZE) * TAB_SIZE) + 1;
+    } else {
+        // a character worth one column
+        ++lex->column;
+    }
+
+    for (; advance > 0; advance--) {
+        lex->chr0 = lex->chr1;
+        lex->chr1 = lex->chr2;
+        lex->src_cur++;
+        if (lex->src_cur + 2 < lex->src_end) {
+            lex->chr2 = lex->src_cur[2];
+        } else {
+            // EOF
+            if (lex->chr1 != '\n' && lex->chr1 != '\r') {
+                lex->chr2 = '\n'; // insert newline at end of file
+            } else {
+                lex->chr2 = CHR_EOF;
+            }
+        }
+    }
+}
+
+void indent_push(py_lexer_t *lex, uint indent) {
+    if (lex->num_indent_level >= lex->alloc_indent_level) {
+        lex->alloc_indent_level *= 2;
+        lex->indent_level = m_renew(uint16_t, lex->indent_level, lex->alloc_indent_level);
+    }
+    lex->indent_level[lex->num_indent_level++] = indent;
+}
+
+uint indent_top(py_lexer_t *lex) {
+    return lex->indent_level[lex->num_indent_level - 1];
+}
+
+void indent_pop(py_lexer_t *lex) {
+    lex->num_indent_level -= 1;
+}
+
+// some tricky operator encoding:
+//     <op>  = begin with <op>, if this opchar matches then begin here
+//     e<op> = end with <op>, if this opchar matches then end
+//     E<op> = mandatory end with <op>, this opchar must match, then end
+//     c<op> = continue with <op>, if this opchar matches then continue matching
+// this means if the start of two ops are the same then they are equal til the last char
+
+static const char *tok_enc =
+    "()[]{},:;@~" // singles
+    "<e=c<e="     // < <= << <<=
+    ">e=c>e="     // > >= >> >>=
+    "*e=c*e="     // * *= ** **=
+    "+e="         // + +=
+    "-e=e>"       // - -= ->
+    "&e="         // & &=
+    "|e="         // | |=
+    "/e=c/e="     // / /= // //=
+    "%e="         // % %=
+    "^e="         // ^ ^=
+    "=e="         // = ==
+    "!E="         // !=
+    ".c.E.";      // . ...
+
+// TODO static assert that number of tokens is less than 256 so we can safely make this table with byte sized entries
+static const uint8_t tok_enc_kind[] = {
+    PY_TOKEN_DEL_PAREN_OPEN, PY_TOKEN_DEL_PAREN_CLOSE,
+    PY_TOKEN_DEL_BRACKET_OPEN, PY_TOKEN_DEL_BRACKET_CLOSE,
+    PY_TOKEN_DEL_BRACE_OPEN, PY_TOKEN_DEL_BRACE_CLOSE,
+    PY_TOKEN_DEL_COMMA, PY_TOKEN_DEL_COLON, PY_TOKEN_DEL_SEMICOLON, PY_TOKEN_DEL_AT, PY_TOKEN_OP_TILDE,
+
+    PY_TOKEN_OP_LESS, PY_TOKEN_OP_LESS_EQUAL, PY_TOKEN_OP_DBL_LESS, PY_TOKEN_DEL_DBL_LESS_EQUAL,
+    PY_TOKEN_OP_MORE, PY_TOKEN_OP_MORE_EQUAL, PY_TOKEN_OP_DBL_MORE, PY_TOKEN_DEL_DBL_MORE_EQUAL,
+    PY_TOKEN_OP_STAR, PY_TOKEN_DEL_STAR_EQUAL, PY_TOKEN_OP_DBL_STAR, PY_TOKEN_DEL_DBL_STAR_EQUAL,
+    PY_TOKEN_OP_PLUS, PY_TOKEN_DEL_PLUS_EQUAL,
+    PY_TOKEN_OP_MINUS, PY_TOKEN_DEL_MINUS_EQUAL, PY_TOKEN_DEL_MINUS_MORE,
+    PY_TOKEN_OP_AMPERSAND, PY_TOKEN_DEL_AMPERSAND_EQUAL,
+    PY_TOKEN_OP_PIPE, PY_TOKEN_DEL_PIPE_EQUAL,
+    PY_TOKEN_OP_SLASH, PY_TOKEN_DEL_SLASH_EQUAL, PY_TOKEN_OP_DBL_SLASH, PY_TOKEN_DEL_DBL_SLASH_EQUAL,
+    PY_TOKEN_OP_PERCENT, PY_TOKEN_DEL_PERCENT_EQUAL,
+    PY_TOKEN_OP_CARET, PY_TOKEN_DEL_CARET_EQUAL,
+    PY_TOKEN_DEL_EQUAL, PY_TOKEN_OP_DBL_EQUAL,
+    PY_TOKEN_OP_NOT_EQUAL,
+    PY_TOKEN_DEL_PERIOD, PY_TOKEN_ELLIPSES,
+};
+
+// must have the same order as enum in lexer.h
+static const char *tok_kw[] = {
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield",
+    NULL,
+};
+
+static void py_lexer_next_token_into(py_lexer_t *lex, py_token_t *tok) {
+    bool had_physical_newline = false;
+
+    while (!is_end(lex)) {
+        if (is_physical_newline(lex)) {
+            had_physical_newline = true;
+            next_char(lex);
+        } else if (is_whitespace(lex)) {
+            next_char(lex);
+        } else if (is_char(lex, '#')) {
+            next_char(lex);
+            while (!is_end(lex) && !is_physical_newline(lex)) {
+                next_char(lex);
+            }
+            // had_physical_newline will be set on next loop
+        } else if (is_char(lex, '\\')) {
+            // backslash (outside string literals) must appear just before a physical newline
+            next_char(lex);
+            if (!is_physical_newline(lex)) {
+                // TODO SyntaxError
+                assert(0);
+            } else {
+                next_char(lex);
+            }
+        } else {
+            break;
+        }
+    }
+
+    tok->src_name = lex->name;
+    tok->src_line = lex->line;
+    tok->src_column = lex->column;
+    tok->kind = PY_TOKEN_INVALID;
+    tok->cont_line = lex->cont_line;
+    tok->str = lex->src_cur;
+    tok->len = 0;
+
+    if (lex->emit_dent < 0) {
+        tok->kind = PY_TOKEN_DEDENT;
+        lex->emit_dent += 1;
+
+    } else if (lex->emit_dent > 0) {
+        tok->kind = PY_TOKEN_INDENT;
+        lex->emit_dent -= 1;
+
+    } else if (had_physical_newline && lex->nested_bracket_level == 0
+                   && tok != &lex->tok_cur // so that we don't emit a newline if file starts with a comment
+               ) {
+        tok->kind = PY_TOKEN_NEWLINE;
+
+        uint num_spaces = lex->column - 1;
+        lex->emit_dent = 0;
+        if (num_spaces == indent_top(lex)) {
+        } else if (num_spaces > indent_top(lex)) {
+            indent_push(lex, num_spaces);
+            lex->emit_dent += 1;
+        } else {
+            while (num_spaces < indent_top(lex)) {
+                indent_pop(lex);
+                lex->emit_dent -= 1;
+            }
+            if (num_spaces != indent_top(lex)) {
+                //SyntaxError
+            }
+        }
+
+    } else if (is_end(lex)) {
+        // TODO emit a newline if file does not end in one
+        if (indent_top(lex) > 0) {
+            tok->kind = PY_TOKEN_NEWLINE;
+            lex->emit_dent = 0;
+            while (indent_top(lex) > 0) {
+                indent_pop(lex);
+                lex->emit_dent -= 1;
+            }
+        } else {
+            tok->kind = PY_TOKEN_END;
+        }
+
+    } else if (is_char_or(lex, '\'', '\"')
+               || (is_char_or3(lex, 'r', 'u', 'b') && is_char_following_or(lex, '\'', '\"'))
+               || ((is_char_and(lex, 'r', 'b') || is_char_and(lex, 'b', 'r')) && is_char_following_following_or(lex, '\'', '\"'))) {
+        // a string or bytes literal
+
+        // parse type codes
+        bool is_raw = false;
+        bool is_bytes = false;
+        if (is_char(lex, 'u')) {
+            next_char(lex);
+        } else if (is_char(lex, 'b')) {
+            is_bytes = true;
+            next_char(lex);
+            if (is_char(lex, 'r')) {
+                is_raw = true;
+                next_char(lex);
+            }
+        } else if (is_char(lex, 'r')) {
+            is_raw = true;
+            next_char(lex);
+            if (is_char(lex, 'b')) {
+                is_bytes = true;
+                next_char(lex);
+            }
+        }
+
+        // set token kind
+        if (is_bytes) {
+            tok->kind = PY_TOKEN_BYTES;
+        } else {
+            tok->kind = PY_TOKEN_STRING;
+        }
+
+        // get first quoting character
+        char quote_char = '\'';
+        if (is_char(lex, '\"')) {
+            quote_char = '\"';
+        }
+        next_char(lex);
+
+        // work out if it's a single or triple quoted literal
+        int num_quotes;
+        if (is_char_and(lex, quote_char, quote_char)) {
+            // triple quotes
+            next_char(lex);
+            next_char(lex);
+            num_quotes = 3;
+        } else {
+            // single quotes
+            num_quotes = 1;
+        }
+
+        // set start of token
+        tok->str = lex->src_cur;
+
+        // parse the literal
+        // TODO proper escaping
+        int n_closing = 0;
+        while (!is_end(lex) && (num_quotes > 1 || !is_char(lex, '\n')) && n_closing < num_quotes) {
+            if (is_char(lex, quote_char)) {
+                n_closing += 1;
+            } else {
+                n_closing = 0;
+                if (!is_raw && is_char(lex, '\\')) {
+                    next_char(lex);
+                }
+            }
+            next_char(lex);
+        }
+
+        // check we got the required end quotes
+        if (n_closing < num_quotes) {
+            tok->kind = PY_TOKEN_LONELY_STRING_OPEN;
+        }
+
+        // set token string (byte) length
+        tok->len = lex->src_cur - tok->str - n_closing;
+
+        // we set the length, return now so it's not set incorrectly below
+        return;
+
+    } else if (is_head_of_identifier(lex)) {
+        tok->kind = PY_TOKEN_NAME;
+
+        next_char(lex);
+
+        while (!is_end(lex) && is_tail_of_identifier(lex)) {
+            next_char(lex);
+        }
+
+    } else if (is_digit(lex) || (is_char(lex, '.') && is_following_digit(lex))) {
+        tok->kind = PY_TOKEN_NUMBER;
+
+        next_char(lex);
+
+        while (!is_end(lex)) {
+            if (is_char_or(lex, 'e', 'E')) {
+                next_char(lex);
+                if (is_char(lex, '+') || is_char(lex, '-')) {
+                    next_char(lex);
+                }
+            } else if (is_letter(lex) || is_digit(lex) || is_char_or(lex, '_', '.')) {
+                next_char(lex);
+            } else {
+                break;
+            }
+        }
+
+    } else {
+        // search for encoded delimiter or operator
+
+        const char *t = tok_enc;
+        uint tok_enc_index = 0;
+        for (; *t != 0 && !is_char(lex, *t); t += 1) {
+            if (*t == 'e' || *t == 'c') {
+                t += 1;
+            } else if (*t == 'E') {
+                tok_enc_index -= 1;
+                t += 1;
+            }
+            tok_enc_index += 1;
+        }
+
+        next_char(lex);
+
+        if (*t == 0) {
+            // didn't match any delimiter or operator characters
+            tok->kind = PY_TOKEN_INVALID;
+
+        } else {
+            // matched a delimiter or operator character
+
+            // get the maximum characters for a valid token
+            t += 1;
+            uint t_index = tok_enc_index;
+            for (;;) {
+                for (; *t == 'e'; t += 1) {
+                    t += 1;
+                    t_index += 1;
+                    if (is_char(lex, *t)) {
+                        next_char(lex);
+                        tok_enc_index = t_index;
+                        break;
+                    }
+                }
+
+                if (*t == 'E') {
+                    t += 1;
+                    if (is_char(lex, *t)) {
+                        next_char(lex);
+                        tok_enc_index = t_index;
+                    } else {
+                        tok->kind = PY_TOKEN_INVALID;
+                    }
+                    break;
+                }
+
+                if (*t == 'c') {
+                    t += 1;
+                    t_index += 1;
+                    if (is_char(lex, *t)) {
+                        next_char(lex);
+                        tok_enc_index = t_index;
+                        t += 1;
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+
+            // set token kind
+            tok->kind = tok_enc_kind[tok_enc_index];
+
+            // compute bracket level for implicit line joining
+            if (tok->kind == PY_TOKEN_DEL_PAREN_OPEN || tok->kind == PY_TOKEN_DEL_BRACKET_OPEN || tok->kind == PY_TOKEN_DEL_BRACE_OPEN) {
+                lex->nested_bracket_level += 1;
+            } else if (tok->kind == PY_TOKEN_DEL_PAREN_CLOSE || tok->kind == PY_TOKEN_DEL_BRACKET_CLOSE || tok->kind == PY_TOKEN_DEL_BRACE_CLOSE) {
+                lex->nested_bracket_level -= 1;
+            }
+        }
+    }
+
+    // set token string (byte) length
+    tok->len = lex->src_cur - tok->str;
+
+    // check for keywords (must be done after setting token string length)
+    if (tok->kind == PY_TOKEN_NAME) {
+        for (int i = 0; tok_kw[i] != NULL; i++) {
+            if (py_token_is_str(tok, tok_kw[i])) {
+                tok->kind = PY_TOKEN_KW_FALSE + i;
+                break;
+            }
+        }
+    }
+}
+
+py_lexer_t *py_lexer_from_str_len(const char *src_name, const char *str, uint len, bool free_str) {
+    py_lexer_t *lex;
+
+    lex = m_new(py_lexer_t, 1);
+
+    //lex->name = g_strdup(src_name); // TODO
+    lex->name = src_name;
+    lex->free = free_str;
+    lex->src_beg = str;
+    lex->src_cur = str;
+    lex->src_end = str + len;
+    lex->line = 1;
+    lex->column = 1;
+    lex->cont_line = lex->line;
+    lex->emit_dent = 0;
+    lex->nested_bracket_level = 0;
+    lex->alloc_indent_level = 16;
+    lex->num_indent_level = 1;
+    lex->indent_level = m_new(uint16_t, lex->alloc_indent_level);
+    lex->indent_level[0] = 0;
+
+    // preload characters
+    // TODO unicode
+    if (len == 0) {
+        lex->chr0 = '\n'; // insert newline at end of file
+        lex->chr1 = CHR_EOF;
+        lex->chr2 = CHR_EOF;
+    } else if (len == 1) {
+        lex->chr0 = str[0];
+        if (lex->chr0 != '\n' && lex->chr0 != '\r') {
+            lex->chr1 = '\n'; // insert newline at end of file
+        } else {
+            lex->chr1 = CHR_EOF;
+        }
+        lex->chr2 = CHR_EOF;
+    } else if (len == 2) {
+        lex->chr0 = str[0];
+        lex->chr1 = str[1];
+        if (lex->chr1 != '\n' && lex->chr1 != '\r') {
+            lex->chr2 = '\n'; // insert newline at end of file
+        } else {
+            lex->chr2 = CHR_EOF;
+        }
+    } else {
+        lex->chr0 = str[0];
+        lex->chr1 = str[1];
+        lex->chr2 = str[2];
+    }
+
+    py_lexer_next_token_into(lex, &lex->tok_cur);
+    py_lexer_next_token_into(lex, &lex->tok_next);
+
+    return lex;
+}
+
+void py_lexer_free(py_lexer_t *lex) {
+    if (lex == NULL) {
+        return;
+    }
+    //m_free(lex->name);
+    if (lex->free) {
+        m_free((char*)lex->src_beg);
+    }
+    m_free(lex);
+}
+
+void py_lexer_to_next(py_lexer_t *lex) {
+    lex->tok_cur = lex->tok_next;
+    py_lexer_next_token_into(lex, &lex->tok_next);
+}
+
+const py_token_t *py_lexer_cur(const py_lexer_t *lex) {
+    return &lex->tok_cur;
+}
+
+bool py_lexer_is_kind(py_lexer_t *lex, py_token_kind_t kind) {
+    return lex->tok_cur.kind == kind;
+}
+
+/*
+bool py_lexer_is_str(py_lexer_t *lex, const char *str) {
+    return py_token_is_str(&lex->tok_cur, str);
+}
+
+bool py_lexer_is_next_kind(py_lexer_t *lex, py_token_kind_t kind) {
+    return lex->tok_next.kind == kind;
+}
+
+bool py_lexer_is_next_str(py_lexer_t *lex, const char *str) {
+    return py_token_is_str(&lex->tok_next, str);
+}
+
+bool py_lexer_opt_kind(py_lexer_t *lex, py_token_kind_t kind) {
+    if (py_lexer_is_kind(lex, kind)) {
+        py_lexer_to_next(lex);
+        return true;
+    }
+    return false;
+}
+
+bool py_lexer_opt_str(py_lexer_t *lex, const char *str) {
+    if (py_lexer_is_str(lex, str)) {
+        py_lexer_to_next(lex);
+        return true;
+    }
+    return false;
+}
+*/
+
+bool py_lexer_show_error(py_lexer_t *lex, const char *msg) {
+    return py_token_show_error(&lex->tok_cur, msg);
+}
diff --git a/py/lexer.h b/py/lexer.h
new file mode 100644
index 0000000..32ab48a
--- /dev/null
+++ b/py/lexer.h
@@ -0,0 +1,141 @@
+/* lexer.h -- simple tokeniser for Python implementation
+ */
+
+#ifndef INCLUDED_LEXER_H
+#define INCLUDED_LEXER_H
+
+/* uses (byte) length instead of null termination
+ * tokens are the same - UTF-8 with (byte) length
+ */
+
+typedef enum _py_token_kind_t {
+    PY_TOKEN_END,                   // 0
+
+    PY_TOKEN_INVALID,
+    PY_TOKEN_LONELY_STRING_OPEN,
+
+    PY_TOKEN_NEWLINE,               // 3
+    PY_TOKEN_INDENT,                // 4
+    PY_TOKEN_DEDENT,                // 5
+
+    PY_TOKEN_NAME,                  // 6
+    PY_TOKEN_NUMBER,
+    PY_TOKEN_STRING,
+    PY_TOKEN_BYTES,
+
+    PY_TOKEN_ELLIPSES,
+
+    PY_TOKEN_KW_FALSE,              // 11
+    PY_TOKEN_KW_NONE,
+    PY_TOKEN_KW_TRUE,
+    PY_TOKEN_KW_AND,
+    PY_TOKEN_KW_AS,
+    PY_TOKEN_KW_ASSERT,
+    PY_TOKEN_KW_BREAK,
+    PY_TOKEN_KW_CLASS,
+    PY_TOKEN_KW_CONTINUE,
+    PY_TOKEN_KW_DEF,                // 20
+    PY_TOKEN_KW_DEL,
+    PY_TOKEN_KW_ELIF,
+    PY_TOKEN_KW_ELSE,
+    PY_TOKEN_KW_EXCEPT,
+    PY_TOKEN_KW_FINALLY,
+    PY_TOKEN_KW_FOR,
+    PY_TOKEN_KW_FROM,
+    PY_TOKEN_KW_GLOBAL,
+    PY_TOKEN_KW_IF,
+    PY_TOKEN_KW_IMPORT,             // 30
+    PY_TOKEN_KW_IN,
+    PY_TOKEN_KW_IS,
+    PY_TOKEN_KW_LAMBDA,
+    PY_TOKEN_KW_NONLOCAL,
+    PY_TOKEN_KW_NOT,
+    PY_TOKEN_KW_OR,
+    PY_TOKEN_KW_PASS,
+    PY_TOKEN_KW_RAISE,
+    PY_TOKEN_KW_RETURN,
+    PY_TOKEN_KW_TRY,                // 40
+    PY_TOKEN_KW_WHILE,
+    PY_TOKEN_KW_WITH,
+    PY_TOKEN_KW_YIELD,
+
+    PY_TOKEN_OP_PLUS,               // 44
+    PY_TOKEN_OP_MINUS,
+    PY_TOKEN_OP_STAR,
+    PY_TOKEN_OP_DBL_STAR,
+    PY_TOKEN_OP_SLASH,
+    PY_TOKEN_OP_DBL_SLASH,
+    PY_TOKEN_OP_PERCENT,
+    PY_TOKEN_OP_LESS,
+    PY_TOKEN_OP_DBL_LESS,
+    PY_TOKEN_OP_MORE,
+    PY_TOKEN_OP_DBL_MORE,           // 54
+    PY_TOKEN_OP_AMPERSAND,
+    PY_TOKEN_OP_PIPE,
+    PY_TOKEN_OP_CARET,
+    PY_TOKEN_OP_TILDE,
+    PY_TOKEN_OP_LESS_EQUAL,
+    PY_TOKEN_OP_MORE_EQUAL,
+    PY_TOKEN_OP_DBL_EQUAL,
+    PY_TOKEN_OP_NOT_EQUAL,
+
+    PY_TOKEN_DEL_PAREN_OPEN,        // 63
+    PY_TOKEN_DEL_PAREN_CLOSE,
+    PY_TOKEN_DEL_BRACKET_OPEN,
+    PY_TOKEN_DEL_BRACKET_CLOSE,
+    PY_TOKEN_DEL_BRACE_OPEN,
+    PY_TOKEN_DEL_BRACE_CLOSE,
+    PY_TOKEN_DEL_COMMA,
+    PY_TOKEN_DEL_COLON,
+    PY_TOKEN_DEL_PERIOD,
+    PY_TOKEN_DEL_SEMICOLON,
+    PY_TOKEN_DEL_AT,                // 73
+    PY_TOKEN_DEL_EQUAL,
+    PY_TOKEN_DEL_PLUS_EQUAL,
+    PY_TOKEN_DEL_MINUS_EQUAL,
+    PY_TOKEN_DEL_STAR_EQUAL,
+    PY_TOKEN_DEL_SLASH_EQUAL,
+    PY_TOKEN_DEL_DBL_SLASH_EQUAL,
+    PY_TOKEN_DEL_PERCENT_EQUAL,
+    PY_TOKEN_DEL_AMPERSAND_EQUAL,
+    PY_TOKEN_DEL_PIPE_EQUAL,
+    PY_TOKEN_DEL_CARET_EQUAL,       // 83
+    PY_TOKEN_DEL_DBL_MORE_EQUAL,
+    PY_TOKEN_DEL_DBL_LESS_EQUAL,
+    PY_TOKEN_DEL_DBL_STAR_EQUAL,
+    PY_TOKEN_DEL_MINUS_MORE,
+} py_token_kind_t;
+
+typedef struct _py_token_t {
+    const char *src_name;       // (file) name of source
+    uint src_line;              // actual source line
+    uint src_column;            // actual source column
+
+    py_token_kind_t kind;       // kind of token
+    uint cont_line;             // token belongs to this line in a continued line
+    const char *str;            // string of token
+    uint len;                   // (byte) length of string of token
+} py_token_t;
+
+typedef struct _py_lexer_t py_lexer_t;
+
+void py_token_show(const py_token_t *tok);
+void py_token_show_error_prefix(const py_token_t *tok);
+bool py_token_show_error(const py_token_t *tok, const char *msg);
+
+py_lexer_t *py_lexer_from_file(const char *filename);
+py_lexer_t *py_lexer_from_str_len(const char *src_name, const char *str, uint len, bool free_str);
+void py_lexer_free(py_lexer_t *lex);
+void py_lexer_to_next(py_lexer_t *lex);
+const py_token_t *py_lexer_cur(const py_lexer_t *lex);
+bool py_lexer_is_kind(py_lexer_t *lex, py_token_kind_t kind);
+/* unused
+bool py_lexer_is_str(py_lexer_t *lex, const char *str);
+bool py_lexer_is_next_kind(py_lexer_t *lex, py_token_kind_t kind);
+bool py_lexer_is_next_str(py_lexer_t *lex, const char *str);
+bool py_lexer_opt_kind(py_lexer_t *lex, py_token_kind_t kind);
+bool py_lexer_opt_str(py_lexer_t *lex, const char *str);
+*/
+bool py_lexer_show_error(py_lexer_t *lex, const char *msg);
+
+#endif /* INCLUDED_LEXER_H */
diff --git a/py/lexerfile.c b/py/lexerfile.c
new file mode 100644
index 0000000..74bb5a0
--- /dev/null
+++ b/py/lexerfile.c
@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "misc.h"
+#include "lexer.h"
+
+py_lexer_t *py_lexer_from_file(const char *filename) {
+    // TODO abstract away file functionality
+    int fd = open(filename, O_RDONLY);
+    if (fd < 0) {
+        printf("cannot open file %s\n", filename);
+        return NULL;
+    }
+    uint size = lseek(fd, 0, SEEK_END);
+    lseek(fd, 0, SEEK_SET);
+    char *data = m_new(char, size);
+    read(fd, data, size);
+    close(fd);
+
+    return py_lexer_from_str_len(filename, data, size, true);
+}
diff --git a/py/machine.h b/py/machine.h
new file mode 100644
index 0000000..fa39c8f
--- /dev/null
+++ b/py/machine.h
@@ -0,0 +1,4 @@
+typedef int64_t machine_int_t; // must be pointer size
+typedef uint64_t machine_uint_t; // must be pointer size
+typedef void *machine_ptr_t; // must be of pointer size
+typedef double machine_float_t;
diff --git a/py/main.c b/py/main.c
new file mode 100644
index 0000000..7b17c38
--- /dev/null
+++ b/py/main.c
@@ -0,0 +1,58 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "compile.h"
+#include "runtime.h"
+
+int main(int argc, char **argv) {
+    qstr_init();
+    rt_init();
+
+    if (argc != 2) {
+        printf("usage: py <file>\n");
+        return 1;
+    }
+    py_lexer_t *lex = py_lexer_from_file(argv[1]);
+    //const char *pysrc = "def f():\n  x=x+1\n  print(42)\n";
+    //py_lexer_t *lex = py_lexer_from_str_len("<>", pysrc, strlen(pysrc), false);
+    if (lex == NULL) {
+        return 1;
+    }
+
+    if (0) {
+        while (!py_lexer_is_kind(lex, PY_TOKEN_END)) {
+            py_token_show(py_lexer_cur(lex));
+            py_lexer_to_next(lex);
+        }
+    } else {
+        py_parse_node_t pn = py_parse(lex, 0);
+        //printf("----------------\n");
+        //parse_node_show(pn, 0);
+        //printf("----------------\n");
+        py_compile(pn);
+        //printf("----------------\n");
+    }
+
+    py_lexer_free(lex);
+
+    if (1) {
+        // execute it
+        py_obj_t module_fun = rt_make_function_from_id(1);
+        if (module_fun != py_const_none) {
+            py_obj_t ret = rt_call_function_0(module_fun);
+            printf("done! got: ");
+            py_obj_print(ret);
+            printf("\n");
+        }
+    }
+
+    rt_deinit();
+
+    //printf("total bytes = %d\n", m_get_total_bytes_allocated());
+    return 0;
+}
diff --git a/py/malloc.c b/py/malloc.c
new file mode 100644
index 0000000..8775f68
--- /dev/null
+++ b/py/malloc.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "misc.h"
+
+static int total_bytes_allocated = 0;
+
+void m_free(void *ptr) {
+    if (ptr != NULL) {
+        free(ptr);
+    }
+}
+
+void *m_malloc(int num_bytes) {
+    if (num_bytes == 0) {
+        return NULL;
+    }
+    void *ptr = malloc(num_bytes);
+    if (ptr == NULL) {
+        printf("could not allocate memory, allocating %d bytes\n", num_bytes);
+        return NULL;
+    }
+    total_bytes_allocated += num_bytes;
+    return ptr;
+}
+
+void *m_malloc0(int num_bytes) {
+    if (num_bytes == 0) {
+        return NULL;
+    }
+    void *ptr = calloc(1, num_bytes);
+    if (ptr == NULL) {
+        printf("could not allocate memory, allocating %d bytes\n", num_bytes);
+        return NULL;
+    }
+    total_bytes_allocated += num_bytes;
+    return ptr;
+}
+
+void *m_realloc(void *ptr, int num_bytes) {
+    if (num_bytes == 0) {
+        free(ptr);
+        return NULL;
+    }
+    ptr = realloc(ptr, num_bytes);
+    if (ptr == NULL) {
+        printf("could not allocate memory, reallocating %d bytes\n", num_bytes);
+        return NULL;
+    }
+    total_bytes_allocated += num_bytes;
+    return ptr;
+}
+
+int m_get_total_bytes_allocated() {
+    return total_bytes_allocated;
+}
diff --git a/py/misc.c b/py/misc.c
new file mode 100644
index 0000000..a5bf8d5
--- /dev/null
+++ b/py/misc.c
@@ -0,0 +1,84 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "misc.h"
+
+// attribute flags
+#define FL_PRINT (0x01)
+#define FL_SPACE (0x02)
+#define FL_DIGIT (0x04)
+#define FL_ALPHA (0x08)
+#define FL_UPPER (0x10)
+#define FL_LOWER (0x20)
+
+// shorthand character attributes
+#define AT_PR (FL_PRINT)
+#define AT_SP (FL_SPACE | FL_PRINT)
+#define AT_DI (FL_DIGIT | FL_PRINT)
+#define AT_AL (FL_ALPHA | FL_PRINT)
+#define AT_UP (FL_UPPER | FL_ALPHA | FL_PRINT)
+#define AT_LO (FL_LOWER | FL_ALPHA | FL_PRINT)
+
+// table of attributes for ascii characters
+static const uint8_t attr[] = {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, AT_SP, AT_SP, AT_SP, 0, AT_SP, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    AT_SP, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR,
+    AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR,
+    AT_DI, AT_DI, AT_DI, AT_DI, AT_DI, AT_DI, AT_DI, AT_DI,
+    AT_DI, AT_DI, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR,
+    AT_PR, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP,
+    AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP,
+    AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP, AT_UP,
+    AT_UP, AT_UP, AT_UP, AT_PR, AT_PR, AT_PR, AT_PR, AT_PR,
+    AT_PR, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO,
+    AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO,
+    AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO, AT_LO,
+    AT_LO, AT_LO, AT_LO, AT_PR, AT_PR, AT_PR, AT_PR, 0
+};
+
+unichar g_utf8_get_char(const char *s) {
+    return *s;
+}
+
+char *g_utf8_next_char(const char *s) {
+    return (char*)(s + 1);
+}
+
+bool g_unichar_isspace(unichar c) {
+    return c < 128 && (attr[c] & FL_SPACE) != 0;
+}
+
+bool g_unichar_isalpha(unichar c) {
+    return c < 128 && (attr[c] & FL_ALPHA) != 0;
+}
+
+bool g_unichar_isprint(unichar c) {
+    return c < 128 && (attr[c] & FL_PRINT) != 0;
+}
+
+bool g_unichar_isdigit(unichar c) {
+    return c < 128 && (attr[c] & FL_DIGIT) != 0;
+}
+
+/*
+bool char_is_alpha_or_digit(unichar c) {
+    return c < 128 && (attr[c] & (FL_ALPHA | FL_DIGIT)) != 0;
+}
+
+bool char_is_upper(unichar c) {
+    return c < 128 && (attr[c] & FL_UPPER) != 0;
+}
+
+bool char_is_lower(unichar c) {
+    return c < 128 && (attr[c] & FL_LOWER) != 0;
+}
+*/
+
+/*
+char *g_strdup(const char *s) {
+    return strdup(s);
+}
+*/
diff --git a/py/misc.h b/py/misc.h
new file mode 100644
index 0000000..9ba80a5
--- /dev/null
+++ b/py/misc.h
@@ -0,0 +1,91 @@
+// a mini library of useful types and functions
+
+#ifndef _INCLUDED_MINILIB_H
+#define _INCLUDED_MINILIB_H
+
+/** types *******************************************************/
+
+typedef int bool;
+enum {
+    false = 0,
+    true = 1
+};
+
+typedef unsigned char byte;
+typedef unsigned int uint;
+
+/** memomry allocation ******************************************/
+
+#define m_new(type, num) ((type*)(m_malloc(sizeof(type) * (num))))
+#define m_new0(type, num) ((type*)(m_malloc0(sizeof(type) * (num))))
+#define m_renew(type, ptr, num) ((type*)(m_realloc((ptr), sizeof(type) * (num))))
+
+void m_free(void *ptr);
+void *m_malloc(int num_bytes);
+void *m_malloc0(int num_bytes);
+void *m_realloc(void *ptr, int num_bytes);
+
+int m_get_total_bytes_allocated();
+
+/** unichar / UTF-8 *********************************************/
+
+typedef int unichar; // TODO
+
+unichar g_utf8_get_char(const char *s);
+char *g_utf8_next_char(const char *s);
+
+bool g_unichar_isspace(unichar c);
+bool g_unichar_isalpha(unichar c);
+bool g_unichar_isprint(unichar c);
+bool g_unichar_isdigit(unichar c);
+
+//char *g_strdup(const char *s);
+
+/** blob ********************************************************/
+
+/*
+unsigned short decode_le16(byte *buf);
+unsigned int decode_le32(byte *buf);
+void encode_le16(byte *buf, unsigned short i);
+void encode_le32(byte *buf, unsigned int i);
+*/
+
+/** string ******************************************************/
+
+/*
+#define streq(s1, s2) (strcmp((s1), (s2)) == 0)
+*/
+
+/** variable string *********************************************/
+
+/*
+typedef struct _vstr_t vstr_t;
+
+vstr_t *vstr_new();
+void vstr_free(vstr_t *vstr);
+void vstr_reset(vstr_t *vstr);
+bool vstr_had_error(vstr_t *vstr);
+char *vstr_str(vstr_t *vstr);
+int vstr_len(vstr_t *vstr);
+void vstr_hint_size(vstr_t *vstr, int size);
+char *vstr_add_len(vstr_t *vstr, int len);
+void vstr_add_str(vstr_t *vstr, const char *str);
+void vstr_add_strn(vstr_t *vstr, const char *str, int len);
+void vstr_add_byte(vstr_t *vstr, byte v);
+void vstr_add_le16(vstr_t *vstr, unsigned short v);
+void vstr_add_le32(vstr_t *vstr, unsigned int v);
+void vstr_cut_tail(vstr_t *vstr, int len);
+void vstr_printf(vstr_t *vstr, const char *fmt, ...);
+*/
+
+/** unique string ***********************************************/
+
+typedef unsigned int qstr;
+
+void qstr_init();
+qstr qstr_from_str_static(const char *str);
+qstr qstr_from_str_take(char *str);
+qstr qstr_from_strn_copy(const char *str, int len);
+const char* qstr_str(qstr qstr);
+
+#endif // _INCLUDED_MINILIB_H
diff --git a/py/parse.c b/py/parse.c
new file mode 100644
index 0000000..94a5a5d
--- /dev/null
+++ b/py/parse.c
@@ -0,0 +1,565 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+
+#define RULE_ACT_KIND_MASK      (0xf0)
+#define RULE_ACT_ARG_MASK       (0x0f)
+#define RULE_ACT_OR             (0x10)
+#define RULE_ACT_AND            (0x20)
+#define RULE_ACT_LIST           (0x30)
+
+#define RULE_ARG_BLANK          (0x0000)
+#define RULE_ARG_KIND_MASK      (0xf000)
+#define RULE_ARG_ARG_MASK       (0x0fff)
+#define RULE_ARG_TOK            (0x1000)
+#define RULE_ARG_RULE           (0x2000)
+#define RULE_ARG_OPT_TOK        (0x3000)
+#define RULE_ARG_OPT_RULE       (0x4000)
+
+// (un)comment to use rule names; for debugging
+//#define USE_RULE_NAME (1)
+
+typedef struct _rule_t {
+    byte rule_id;
+    byte act;
+#ifdef USE_RULE_NAME
+    const char *rule_name;
+#endif
+    uint16_t arg[];
+} rule_t;
+
+enum {
+    RULE_none = 0,
+#define DEF_RULE(rule, comp, kind, arg...) RULE_##rule,
+#include "grammar.h"
+#undef DEF_RULE
+    RULE_maximum_number_of,
+};
+
+#define or(n)                   (RULE_ACT_OR | n)
+#define and(n)                  (RULE_ACT_AND | n)
+#define one_or_more             (RULE_ACT_LIST | 2)
+#define list                    (RULE_ACT_LIST | 1)
+#define list_with_end           (RULE_ACT_LIST | 3)
+#define tok(t)                  (RULE_ARG_TOK | PY_TOKEN_##t)
+#define rule(r)                 (RULE_ARG_RULE | RULE_##r)
+#define opt_tok(t)              (RULE_ARG_OPT_TOK | PY_TOKEN_##t)
+#define opt_rule(r)             (RULE_ARG_OPT_RULE | RULE_##r)
+#ifdef USE_RULE_NAME
+#define DEF_RULE(rule, comp, kind, arg...) static rule_t rule_##rule = { RULE_##rule, kind, #rule, { arg } };
+#else
+#define DEF_RULE(rule, comp, kind, arg...) static rule_t rule_##rule = { RULE_##rule, kind, { arg } };
+#endif
+#include "grammar.h"
+#undef or
+#undef and
+#undef list
+#undef list_with_end
+#undef tok
+#undef rule
+#undef opt_tok
+#undef opt_rule
+#undef one_or_more
+#undef DEF_RULE
+
+static rule_t *rules[] = {
+    NULL,
+#define DEF_RULE(rule, comp, kind, arg...) &rule_##rule,
+#include "grammar.h"
+#undef DEF_RULE
+};
+
+typedef struct _rule_stack_t {
+    byte rule_id;
+    int32_t arg_i; // what should be the size and signedness?
+} rule_stack_t;
+
+typedef struct _parser_t {
+    uint rule_stack_alloc;
+    uint rule_stack_top;
+    rule_stack_t *rule_stack;
+
+    uint result_stack_top;
+    py_parse_node_t *result_stack;
+} parser_t;
+
+static void push_rule(parser_t *parser, rule_t *rule, int arg_i) {
+    if (parser->rule_stack_top >= parser->rule_stack_alloc) {
+        parser->rule_stack_alloc *= 2;
+        parser->rule_stack = m_renew(rule_stack_t, parser->rule_stack, parser->rule_stack_alloc);
+    }
+    parser->rule_stack[parser->rule_stack_top].rule_id = rule->rule_id;
+    parser->rule_stack[parser->rule_stack_top].arg_i = arg_i;
+    parser->rule_stack_top += 1;
+}
+
+static void push_rule_from_arg(parser_t *parser, uint arg) {
+    assert((arg & RULE_ARG_KIND_MASK) == RULE_ARG_RULE || (arg & RULE_ARG_KIND_MASK) == RULE_ARG_OPT_RULE);
+    uint rule_id = arg & RULE_ARG_ARG_MASK;
+    assert(rule_id < RULE_maximum_number_of);
+    push_rule(parser, rules[rule_id], 0);
+}
+
+static void pop_rule(parser_t *parser, rule_t **rule, uint *arg_i) {
+    parser->rule_stack_top -= 1;
+    *rule = rules[parser->rule_stack[parser->rule_stack_top].rule_id];
+    *arg_i = parser->rule_stack[parser->rule_stack_top].arg_i;
+}
+
+py_parse_node_t py_parse_node_new_leaf(machine_int_t kind, machine_int_t arg) {
+    return (py_parse_node_t)(kind | (arg << 4));
+}
+
+int num_parse_nodes_allocated = 0;
+py_parse_node_struct_t *parse_node_new_struct(int rule_id, int num_args) {
+    py_parse_node_struct_t *pn = m_malloc(sizeof(py_parse_node_struct_t) + num_args * sizeof(py_parse_node_t));
+    pn->source = 0; // TODO
+    pn->kind_num_nodes = (rule_id & 0xff) | (num_args << 8);
+    num_parse_nodes_allocated += 1;
+    return pn;
+}
+
+void parse_node_show(py_parse_node_t pn, int indent) {
+    for (int i = 0; i < indent; i++) {
+        printf(" ");
+    }
+    if (PY_PARSE_NODE_IS_NULL(pn)) {
+        printf("NULL\n");
+    } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
+        int arg = PY_PARSE_NODE_LEAF_ARG(pn);
+        switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
+            case PY_PARSE_NODE_ID: printf("id(%s)\n", qstr_str(arg)); break;
+            case PY_PARSE_NODE_SMALL_INT: printf("int(%d)\n", arg); break;
+            case PY_PARSE_NODE_INTEGER: printf("int(%s)\n", qstr_str(arg)); break;
+            case PY_PARSE_NODE_DECIMAL: printf("dec(%s)\n", qstr_str(arg)); break;
+            case PY_PARSE_NODE_STRING: printf("str(%s)\n", qstr_str(arg)); break;
+            case PY_PARSE_NODE_BYTES: printf("bytes(%s)\n", qstr_str(arg)); break;
+            case PY_PARSE_NODE_TOKEN: printf("tok(%d)\n", arg); break;
+            default: assert(0);
+        }
+    } else {
+        py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pn;
+        int n = pns2->kind_num_nodes >> 8;
+#ifdef USE_RULE_NAME
+        printf("%s(%d) (n=%d)\n", rules[PY_PARSE_NODE_STRUCT_KIND(pns2)]->rule_name, PY_PARSE_NODE_STRUCT_KIND(pns2), n);
+#else
+        printf("rule(%u) (n=%d)\n", (uint)PY_PARSE_NODE_STRUCT_KIND(pns2), n);
+#endif
+        for (int i = 0; i < n; i++) {
+            parse_node_show(pns2->nodes[i], indent + 2);
+        }
+    }
+}
+
+/*
+static void result_stack_show(parser_t *parser) {
+    printf("result stack, most recent first\n");
+    for (int i = parser->result_stack_top - 1; i >= 0; i--) {
+        parse_node_show(parser->result_stack[i], 0);
+    }
+}
+*/
+
+static py_parse_node_t pop_result(parser_t *parser) {
+    assert(parser->result_stack_top > 0);
+    return parser->result_stack[--parser->result_stack_top];
+}
+
+static py_parse_node_t peek_result(parser_t *parser, int pos) {
+    assert(parser->result_stack_top > pos);
+    return parser->result_stack[parser->result_stack_top - 1 - pos];
+}
+
+static void push_result_node(parser_t *parser, py_parse_node_t pn) {
+    parser->result_stack[parser->result_stack_top++] = pn;
+}
+
+static void push_result_token(parser_t *parser, const py_lexer_t *lex) {
+    const py_token_t *tok = py_lexer_cur(lex);
+    py_parse_node_t pn;
+    if (tok->kind == PY_TOKEN_NAME) {
+        pn = py_parse_node_new_leaf(PY_PARSE_NODE_ID, qstr_from_strn_copy(tok->str, tok->len));
+    } else if (tok->kind == PY_TOKEN_NUMBER) {
+        bool dec = false;
+        bool small_int = true;
+        int int_val = 0;
+        int len = tok->len;
+        const char *str = tok->str;
+        int base = 10;
+        int i = 0;
+        if (len >= 3 && str[0] == '0') {
+            if (str[1] == 'o' || str[1] == 'O') {
+                // octal
+                base = 8;
+                i = 2;
+            } else if (str[1] == 'x' || str[1] == 'X') {
+                // hexadecimal
+                base = 16;
+                i = 2;
+            } else if (str[1] == 'b' || str[1] == 'B') {
+                // binary
+                base = 2;
+                i = 2;
+            }
+        }
+        for (; i < len; i++) {
+            if (g_unichar_isdigit(str[i]) && str[i] - '0' < base) {
+                int_val = base * int_val + str[i] - '0';
+            } else if (base == 16 && 'a' <= str[i] && str[i] <= 'f') {
+                int_val = base * int_val + str[i] - 'a' + 10;
+            } else if (base == 16 && 'F' <= str[i] && str[i] <= 'F') {
+                int_val = base * int_val + str[i] - 'A' + 10;
+            } else if (str[i] == '.' || str[i] == 'e' || str[i] == 'E') {
+                dec = true;
+                break;
+            } else {
+                small_int = false;
+                break;
+            }
+        }
+        if (dec) {
+            pn = py_parse_node_new_leaf(PY_PARSE_NODE_DECIMAL, qstr_from_strn_copy(str, len));
+        } else if (small_int && -0x10000 <= int_val && int_val <= 0xffff) {
+            pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, int_val);
+        } else {
+            pn = py_parse_node_new_leaf(PY_PARSE_NODE_INTEGER, qstr_from_strn_copy(str, len));
+        }
+    } else if (tok->kind == PY_TOKEN_STRING) {
+        pn = py_parse_node_new_leaf(PY_PARSE_NODE_STRING, qstr_from_strn_copy(tok->str, tok->len));
+    } else if (tok->kind == PY_TOKEN_BYTES) {
+        pn = py_parse_node_new_leaf(PY_PARSE_NODE_BYTES, qstr_from_strn_copy(tok->str, tok->len));
+    } else {
+        pn = py_parse_node_new_leaf(PY_PARSE_NODE_TOKEN, tok->kind);
+    }
+    push_result_node(parser, pn);
+}
+
+static void push_result_rule(parser_t *parser, rule_t *rule, int num_args) {
+    py_parse_node_struct_t *pn = parse_node_new_struct(rule->rule_id, num_args);
+    for (int i = num_args; i > 0; i--) {
+        pn->nodes[i - 1] = pop_result(parser);
+    }
+    push_result_node(parser, (py_parse_node_t)pn);
+}
+
+py_parse_node_t py_parse(py_lexer_t *lex, int wanted_rule) {
+    wanted_rule = RULE_file_input;
+    parser_t *parser = m_new(parser_t, 1);
+    parser->rule_stack_alloc = 64;
+    parser->rule_stack_top = 0;
+    parser->rule_stack = m_new(rule_stack_t, parser->rule_stack_alloc);
+
+    parser->result_stack = m_new(py_parse_node_t, 1000);
+    parser->result_stack_top = 0;
+
+    push_rule(parser, rules[wanted_rule], 0);
+
+    uint n, i;
+    bool backtrack = false;
+    rule_t *rule;
+    py_token_kind_t tok_kind;
+    bool emit_rule;
+    bool had_trailing_sep;
+
+    for (;;) {
+        next_rule:
+        if (parser->rule_stack_top == 0) {
+            break;
+        }
+
+        pop_rule(parser, &rule, &i);
+        n = rule->act & RULE_ACT_ARG_MASK;
+
+        /*
+        // debugging
+        printf("depth=%d ", parser->rule_stack_top);
+        for (int j = 0; j < parser->rule_stack_top; ++j) {
+            printf(" ");
+        }
+        printf("%s n=%d i=%d bt=%d\n", rule->rule_name, n, i, backtrack);
+        */
+
+        switch (rule->act & RULE_ACT_KIND_MASK) {
+            case RULE_ACT_OR:
+                if (i > 0 && !backtrack) {
+                    goto next_rule;
+                } else {
+                    backtrack = false;
+                }
+                for (; i < n - 1; ++i) {
+                    switch (rule->arg[i] & RULE_ARG_KIND_MASK) {
+                        case RULE_ARG_TOK:
+                            if (py_lexer_is_kind(lex, rule->arg[i] & RULE_ARG_ARG_MASK)) {
+                                push_result_token(parser, lex);
+                                py_lexer_to_next(lex);
+                                goto next_rule;
+                            }
+                            break;
+                        case RULE_ARG_RULE:
+                            push_rule(parser, rule, i + 1);
+                            push_rule_from_arg(parser, rule->arg[i]);
+                            goto next_rule;
+                        default:
+                            assert(0);
+                    }
+                }
+                if ((rule->arg[i] & RULE_ARG_KIND_MASK) == RULE_ARG_TOK) {
+                    if (py_lexer_is_kind(lex, rule->arg[i] & RULE_ARG_ARG_MASK)) {
+                        push_result_token(parser, lex);
+                        py_lexer_to_next(lex);
+                    } else {
+                        backtrack = true;
+                        goto next_rule;
+                    }
+                } else {
+                    push_rule_from_arg(parser, rule->arg[i]);
+                }
+                break;
+
+            case RULE_ACT_AND:
+
+                // failed, backtrack if we can, else syntax error
+                if (backtrack) {
+                    assert(i > 0);
+                    if ((rule->arg[i - 1] & RULE_ARG_KIND_MASK) == RULE_ARG_OPT_RULE) {
+                        // an optional rule that failed, so continue with next arg
+                        push_result_node(parser, PY_PARSE_NODE_NULL);
+                        backtrack = false;
+                    } else {
+                        // a mandatory rule that failed, so propagate backtrack
+                        if (i > 1) {
+                            // already eaten tokens so can't backtrack
+                            goto syntax_error;
+                        } else {
+                            goto next_rule;
+                        }
+                    }
+                }
+
+                // progress through the rule
+                for (; i < n; ++i) {
+                    switch (rule->arg[i] & RULE_ARG_KIND_MASK) {
+                        case RULE_ARG_TOK:
+                            // need to match a token
+                            tok_kind = rule->arg[i] & RULE_ARG_ARG_MASK;
+                            if (py_lexer_is_kind(lex, tok_kind)) {
+                                // matched token
+                                if (tok_kind == PY_TOKEN_NAME) {
+                                    push_result_token(parser, lex);
+                                }
+                                py_lexer_to_next(lex);
+                            } else {
+                                // failed to match token
+                                if (i > 0) {
+                                    // already eaten tokens so can't backtrack
+                                    goto syntax_error;
+                                } else {
+                                    // this rule failed, so backtrack
+                                    backtrack = true;
+                                    goto next_rule;
+                                }
+                            }
+                            break;
+                        case RULE_ARG_RULE:
+                            //if (i + 1 < n) {
+                                push_rule(parser, rule, i + 1);
+                            //}
+                            push_rule_from_arg(parser, rule->arg[i]);
+                            goto next_rule;
+                        case RULE_ARG_OPT_RULE:
+                            push_rule(parser, rule, i + 1);
+                            push_rule_from_arg(parser, rule->arg[i]);
+                            goto next_rule;
+                        default:
+                            assert(0);
+                    }
+                }
+
+                assert(i == n);
+
+                // matched the rule, so now build the corresponding parse_node
+
+                // count number of arguments for the parse_node
+                i = 0;
+                emit_rule = false;
+                for (int x = 0; x < n; ++x) {
+                    if ((rule->arg[x] & RULE_ARG_KIND_MASK) == RULE_ARG_TOK) {
+                        tok_kind = rule->arg[x] & RULE_ARG_ARG_MASK;
+                        if (tok_kind >= PY_TOKEN_NAME) {
+                            emit_rule = true;
+                        }
+                        if (tok_kind == PY_TOKEN_NAME) {
+                            // only tokens which were names are pushed to stack
+                            i += 1;
+                        }
+                    } else {
+                        // rules are always pushed
+                        i += 1;
+                    }
+                }
+
+                // always emit these rules, even if they have only 1 argument
+                if (rule->rule_id == RULE_expr_stmt || rule->rule_id == RULE_yield_stmt) {
+                    emit_rule = true;
+                }
+
+                // never emit these rules if they have only 1 argument
+                // NOTE: can't put atom_paren here because we need it to distinguisg, for example, [a,b] from [(a,b)]
+                if (rule->rule_id == RULE_else_stmt || rule->rule_id == RULE_testlist_comp_3b || rule->rule_id == RULE_import_as_names_paren || rule->rule_id == RULE_typedargslist_colon || rule->rule_id == RULE_typedargslist_equal || rule->rule_id == RULE_dictorsetmaker_colon || rule->rule_id == RULE_classdef_2 || rule->rule_id == RULE_with_item_as || rule->rule_id == RULE_assert_stmt_extra || rule->rule_id == RULE_as_name || rule->rule_id == RULE_raise_stmt_from || rule->rule_id == RULE_vfpdef) {
+                    emit_rule = false;
+                }
+
+                // always emit these rules, and add an extra blank node at the end (to be used by the compiler to store data)
+                if (rule->rule_id == RULE_funcdef || rule->rule_id == RULE_classdef || rule->rule_id == RULE_comp_for || rule->rule_id == RULE_lambdef || rule->rule_id == RULE_lambdef_nocond) {
+                    emit_rule = true;
+                    push_result_node(parser, PY_PARSE_NODE_NULL);
+                    i += 1;
+                }
+
+                int num_not_nil = 0;
+                for (int x = 0; x < i; ++x) {
+                    if (peek_result(parser, x) != PY_PARSE_NODE_NULL) {
+                        num_not_nil += 1;
+                    }
+                }
+                //printf("done and %s n=%d i=%d notnil=%d\n", rule->rule_name, n, i, num_not_nil);
+                if (emit_rule) {
+                    push_result_rule(parser, rule, i);
+                } else if (num_not_nil == 0) {
+                    push_result_rule(parser, rule, i); // needed for, eg, atom_paren, testlist_comp_3b
+                    //result_stack_show(parser);
+                    //assert(0);
+                } else if (num_not_nil == 1) {
+                    // single result, leave it on stack
+                    py_parse_node_t pn = PY_PARSE_NODE_NULL;
+                    for (int x = 0; x < i; ++x) {
+                        py_parse_node_t pn2 = pop_result(parser);
+                        if (pn2 != PY_PARSE_NODE_NULL) {
+                            pn = pn2;
+                        }
+                    }
+                    push_result_node(parser, pn);
+                } else {
+                    push_result_rule(parser, rule, i);
+                }
+                break;
+
+            case RULE_ACT_LIST:
+                // n=2 is: item item*
+                // n=1 is: item (sep item)*
+                // n=3 is: item (sep item)* [sep]
+                if (backtrack) {
+                    list_backtrack:
+                    had_trailing_sep = false;
+                    if (n == 2) {
+                        if (i == 1) {
+                            // fail on item, first time round; propagate backtrack
+                            goto next_rule;
+                        } else {
+                            // fail on item, in later rounds; finish with this rule
+                            backtrack = false;
+                        }
+                    } else {
+                        if (i == 1) {
+                            // fail on item, first time round; propagate backtrack
+                            goto next_rule;
+                        } else if ((i & 1) == 1) {
+                            // fail on item, in later rounds; have eaten tokens so can't backtrack
+                            if (n == 3) {
+                                // list allows trailing separator; finish parsing list
+                                had_trailing_sep = true;
+                                backtrack = false;
+                            } else {
+                                // list doesn't allowing trailing separator; fail
+                                goto syntax_error;
+                            }
+                        } else {
+                            // fail on separator; finish parsing list
+                            backtrack = false;
+                        }
+                    }
+                } else {
+                    for (;;) {
+                        uint arg = rule->arg[i & 1 & n];
+                        switch (arg & RULE_ARG_KIND_MASK) {
+                            case RULE_ARG_TOK:
+                                if (py_lexer_is_kind(lex, arg & RULE_ARG_ARG_MASK)) {
+                                    if (i & 1 & n) {
+                                        // separators which are tokens are not pushed to result stack
+                                    } else {
+                                        push_result_token(parser, lex);
+                                    }
+                                    py_lexer_to_next(lex);
+                                    // got element of list, so continue parsing list
+                                    i += 1;
+                                } else {
+                                    // couldn't get element of list
+                                    i += 1;
+                                    backtrack = true;
+                                    goto list_backtrack;
+                                }
+                                break;
+                            case RULE_ARG_RULE:
+                                push_rule(parser, rule, i + 1);
+                                push_rule_from_arg(parser, arg);
+                                goto next_rule;
+                            default:
+                                assert(0);
+                        }
+                    }
+                }
+                assert(i >= 1);
+
+                // compute number of elements in list, result in i
+                i -= 1;
+                if ((n & 1) && (rule->arg[1] & RULE_ARG_KIND_MASK) == RULE_ARG_TOK) {
+                    // don't count separators when they are tokens
+                    i = (i + 1) / 2;
+                }
+
+                if (i == 1) {
+                    // list matched single item
+                    if (had_trailing_sep) {
+                        // if there was a trailing separator, make a list of a single item
+                        push_result_rule(parser, rule, i);
+                    } else {
+                        // just leave single item on stack (ie don't wrap in a list)
+                    }
+                } else {
+                    //printf("done list %s %d %d\n", rule->rule_name, n, i);
+                    push_result_rule(parser, rule, i);
+                }
+                break;
+
+            default:
+                assert(0);
+        }
+    }
+    if (!py_lexer_is_kind(lex, PY_TOKEN_END)) {
+        py_lexer_show_error(lex, "unexpected token at end:");
+        py_token_show(py_lexer_cur(lex));
+    }
+    //printf("--------------\n");
+    //result_stack_show(parser);
+    assert(parser->result_stack_top == 1);
+    //printf("maximum depth: %d\n", parser->rule_stack_alloc);
+    //printf("number of parse nodes allocated: %d\n", num_parse_nodes_allocated);
+    return parser->result_stack[0];
+
+syntax_error:
+    py_lexer_show_error(lex, "syntax error:");
+#ifdef USE_RULE_NAME
+    py_lexer_show_error(lex, rule->rule_name);
+#endif
+    py_token_show(py_lexer_cur(lex));
+    return PY_PARSE_NODE_NULL;
+}
diff --git a/py/parse.h b/py/parse.h
new file mode 100644
index 0000000..07d553c
--- /dev/null
+++ b/py/parse.h
@@ -0,0 +1,54 @@
+struct _py_lexer_t;
+
+// a py_parse_node_t is:
+//  - 0000...0000: no node
+//  - xxxx...0001: an identifier; bits 4 and above are the qstr
+//  - xxxx...0011: a small integer; bits 4 and above are the signed value, 2's complement
+//  - xxxx...0101: an integer; bits 4 and above are the qstr holding the value
+//  - xxxx...0111: a decimal; bits 4 and above are the qstr holding the value
+//  - xxxx...1001: a string; bits 4 and above are the qstr holding the value
+//  - xxxx...1011: a string with triple quotes; bits 4 and above are the qstr holding the value
+//  - xxxx...1101: a token; bits 4 and above are py_token_kind_t
+//  - xxxx...xxx0: pointer to py_parse_node_struct_t
+
+#define PY_PARSE_NODE_NULL      (0)
+#define PY_PARSE_NODE_ID        (0x1)
+#define PY_PARSE_NODE_SMALL_INT (0x3)
+#define PY_PARSE_NODE_INTEGER   (0x5)
+#define PY_PARSE_NODE_DECIMAL   (0x7)
+#define PY_PARSE_NODE_STRING    (0x9)
+#define PY_PARSE_NODE_BYTES     (0xb)
+#define PY_PARSE_NODE_TOKEN     (0xd)
+
+typedef machine_uint_t py_parse_node_t; // must be pointer size
+
+typedef struct _py_parse_node_struct_t {
+    uint32_t source;            // file identifier, and line number
+    uint32_t kind_num_nodes;    // parse node kind, and number of nodes
+    py_parse_node_t nodes[];    // nodes
+} py_parse_node_struct_t;
+
+// macros for py_parse_node_t usage
+// some of these evaluate their argument more than once
+
+#define PY_PARSE_NODE_IS_NULL(pn) ((pn) == PY_PARSE_NODE_NULL)
+#define PY_PARSE_NODE_IS_LEAF(pn) ((pn) & 1)
+#define PY_PARSE_NODE_IS_STRUCT(pn) ((pn) != PY_PARSE_NODE_NULL && ((pn) & 1) == 0)
+#define PY_PARSE_NODE_IS_STRUCT_KIND(pn, k) ((pn) != PY_PARSE_NODE_NULL && ((pn) & 1) == 0 && PY_PARSE_NODE_STRUCT_KIND((py_parse_node_struct_t*)(pn)) == (k))
+
+#define PY_PARSE_NODE_IS_ID(pn) (((pn) & 0xf) == PY_PARSE_NODE_ID)
+#define PY_PARSE_NODE_IS_SMALL_INT(pn) (((pn) & 0xf) == PY_PARSE_NODE_SMALL_INT)
+#define PY_PARSE_NODE_IS_TOKEN(pn) (((pn) & 0xf) == PY_PARSE_NODE_TOKEN)
+#define PY_PARSE_NODE_IS_TOKEN_KIND(pn, k) ((pn) == (PY_PARSE_NODE_TOKEN | (k << 4)))
+
+#define PY_PARSE_NODE_LEAF_KIND(pn) ((pn) & 0xf)
+// TODO should probably have int and uint versions of this macro
+#define PY_PARSE_NODE_LEAF_ARG(pn) (((machine_int_t)(pn)) >> 4)
+#define PY_PARSE_NODE_STRUCT_KIND(pns) ((pns)->kind_num_nodes & 0xff)
+#define PY_PARSE_NODE_STRUCT_NUM_NODES(pns) ((pns)->kind_num_nodes >> 8)
+
+py_parse_node_t py_parse_node_new_leaf(machine_int_t kind, machine_int_t arg);
+
+void parse_node_show(py_parse_node_t pn, int indent);
+
+py_parse_node_t py_parse(struct _py_lexer_t *lex, int wanted_rule);
diff --git a/py/qstr.c b/py/qstr.c
new file mode 100644
index 0000000..33d15c7
--- /dev/null
+++ b/py/qstr.c
@@ -0,0 +1,56 @@
+#include <assert.h>
+#include <string.h>
+
+#include "misc.h"
+
+static int qstrs_alloc;
+static int qstrs_len;
+static const char **qstrs;
+
+void qstr_init() {
+    qstrs_alloc = 400;
+    qstrs_len = 1;
+    qstrs = m_new(const char*, qstrs_alloc);
+    qstrs[0] = "nil";
+}
+
+static qstr qstr_add(const char *str) {
+    if (qstrs_len >= qstrs_alloc) {
+        qstrs_alloc *= 2;
+        qstrs = m_renew(const char*, qstrs, qstrs_alloc);
+    }
+    qstrs[qstrs_len++] = str;
+    return qstrs_len - 1;
+}
+
+qstr qstr_from_str_static(const char *str) {
+    for (int i = 0; i < qstrs_len; i++) {
+        if (strcmp(qstrs[i], str) == 0) {
+            return i;
+        }
+    }
+    return qstr_add(str);
+}
+
+qstr qstr_from_str_take(char *str) {
+    for (int i = 0; i < qstrs_len; i++) {
+        if (strcmp(qstrs[i], str) == 0) {
+            m_free(str);
+            return i;
+        }
+    }
+    return qstr_add(str);
+}
+
+qstr qstr_from_strn_copy(const char *str, int len) {
+    for (int i = 0; i < qstrs_len; i++) {
+        if (strncmp(qstrs[i], str, len) == 0 && qstrs[i][len] == '\0') {
+            return i;
+        }
+    }
+    return qstr_add(strndup(str, len));
+}
+
+const char *qstr_str(qstr qstr) {
+    return qstrs[qstr];
+}
diff --git a/py/runtime.c b/py/runtime.c
new file mode 100644
index 0000000..bf2e2ee
--- /dev/null
+++ b/py/runtime.c
@@ -0,0 +1,944 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "runtime.h"
+#include "bc.h"
+
+#define DEBUG_printf(args...) (void)0
+//#define DEBUG_printf(args...) printf(args)
+
+#define DEBUG_OP_printf(args...) (void)0
+//#define DEBUG_OP_printf(args...) printf(args)
+
+// enable/disable float support with this definition
+#define PY_FLOAT (1)
+
+typedef machine_int_t py_small_int_t;
+
+#define IS_O(o, k) (((((py_small_int_t)(o)) & 1) == 0) && (((py_obj_base_t*)(o))->kind == (k)))
+#define IS_SMALL_INT(o) (((py_small_int_t)(o)) & 1)
+#define FROM_SMALL_INT(o) (((py_small_int_t)(o)) >> 1)
+#define TO_SMALL_INT(o) ((py_obj_t)(((o) << 1) | 1))
+
+#ifdef PY_FLOAT
+typedef machine_float_t float_t;
+#endif
+
+typedef enum {
+    O_CONST,
+    O_STR,
+#ifdef PY_FLOAT
+    O_FLOAT,
+#endif
+    O_FUN_0,
+    O_FUN_1,
+    O_FUN_2,
+    O_FUN_N,
+    O_FUN_BC,
+    O_BOUND_METH,
+    O_LIST,
+    O_SET,
+    O_MAP,
+    O_CLASS,
+} py_obj_kind_t;
+
+typedef enum {
+    MAP_QSTR,
+    MAP_PY_OBJ,
+} py_map_kind_t;
+
+typedef struct _py_map_elem_t {
+    py_obj_t key;
+    py_obj_t value;
+} py_map_elem_t;
+
+typedef struct _py_map_t {
+    py_map_kind_t kind;
+    machine_uint_t alloc;
+    machine_uint_t used;
+    py_map_elem_t *table;
+} py_map_t;
+
+typedef struct _py_obj_base_t {
+    py_obj_kind_t kind;
+    union {
+        const char *id;
+        qstr u_str;
+#ifdef PY_FLOAT
+        float_t flt;
+#endif
+        struct { // for O_FUN_[012N]
+            void *fun;
+            int n_args;
+        } u_fun;
+        struct { // for O_FUN_BC
+            byte *code;
+            uint len;
+            int n_args;
+        } u_fun_bc;
+        struct { // for O_BOUND_METH
+            py_obj_t meth;
+            py_obj_t self;
+        } u_bound_meth;
+        struct { // for O_LIST
+            int alloc;
+            int len;
+            py_obj_t *items;
+        } u_list;
+        struct { // for O_SET
+            int alloc;
+            int used;
+            py_obj_t *table;
+        } u_set;
+        py_map_t u_map; // for O_MAP
+        /*
+        struct { // for O_MAP
+            int alloc;
+            int used;
+            py_map_elem_t *table;
+        } u_map;
+        */
+        struct { // for O_CLASS
+            py_map_t *map;
+        } u_class;
+    };
+} py_obj_base_t;
+
+py_obj_t py_const_none;
+py_obj_t py_const_false;
+py_obj_t py_const_true;
+
+py_map_t map_name;
+py_map_t map_builtins;
+
+// approximatelly doubling primes; made with Mathematica command: Table[Prime[Floor[(1.7)^n]], {n, 3, 24}]
+static int doubling_primes[] = {7, 19, 43, 89, 179, 347, 647, 1229, 2297, 4243, 7829, 14347, 26017, 47149, 84947, 152443, 273253, 488399, 869927, 1547173, 2745121, 4861607};
+
+int get_doubling_prime_greater_or_equal_to(int x) {
+    for (int i = 0; i < sizeof(doubling_primes) / sizeof(int); i++) {
+        if (doubling_primes[i] >= x) {
+            return doubling_primes[i];
+        }
+    }
+    // ran out of primes in the table!
+    // return something sensible, at least make it odd
+    return x | 1;
+}
+
+void py_map_init(py_map_t *map, py_map_kind_t kind, int n) {
+    map->kind = kind;
+    map->alloc = get_doubling_prime_greater_or_equal_to(n + 1);
+    map->used = 0;
+    map->table = m_new(py_map_elem_t, map->alloc);
+    for (int i = 0; i < map->alloc; i++) {
+        map->table[i].key = NULL;
+        map->table[i].value = NULL;
+    }
+}
+
+py_map_t *py_map_new(py_map_kind_t kind, int n) {
+    py_map_t *map = m_new(py_map_t, 1);
+    py_map_init(map, kind, n);
+    return map;
+}
+
+int py_obj_hash(py_obj_t o_in) {
+    if (IS_SMALL_INT(o_in)) {
+        return FROM_SMALL_INT(o_in);
+    } else if (IS_O(o_in, O_STR)) {
+        return ((py_obj_base_t*)o_in)->u_str;
+    } else {
+        assert(0);
+        return 0;
+    }
+}
+
+bool py_obj_equal(py_obj_t o1, py_obj_t o2) {
+    if (o1 == o2) {
+        return true;
+    } else if (IS_SMALL_INT(o1) && IS_SMALL_INT(o2)) {
+        return false;
+    } else if (IS_O(o1, O_STR) && IS_O(o2, O_STR)) {
+        return ((py_obj_base_t*)o1)->u_str == ((py_obj_base_t*)o2)->u_str;
+    } else {
+        assert(0);
+        return false;
+    }
+}
+
+py_map_elem_t* py_map_lookup_helper(py_map_t *map, py_obj_t index, bool add_if_not_found) {
+    bool is_map_py_obj = (map->kind == MAP_PY_OBJ);
+    machine_uint_t hash;
+    if (is_map_py_obj) {
+        hash = py_obj_hash(index);
+    } else {
+        hash = (machine_uint_t)index;
+    }
+    uint pos = hash % map->alloc;
+    for (;;) {
+        py_map_elem_t *elem = &map->table[pos];
+        if (elem->key == NULL) {
+            // not in table
+            if (add_if_not_found) {
+                if (map->used + 1 >= map->alloc) {
+                    // not enough room in table, rehash it
+                    int old_alloc = map->alloc;
+                    py_map_elem_t *old_table = map->table;
+                    map->alloc = get_doubling_prime_greater_or_equal_to(map->alloc + 1);
+                    map->used = 0;
+                    map->table = m_new(py_map_elem_t, map->alloc);
+                    for (int i = 0; i < old_alloc; i++) {
+                        if (old_table[i].key != NULL) {
+                            py_map_lookup_helper(map, old_table[i].key, true)->value = old_table[i].value;
+                        }
+                    }
+                    m_free(old_table);
+                    // restart the search for the new element
+                    pos = hash % map->alloc;
+                } else {
+                    map->used += 1;
+                    elem->key = index;
+                    return elem;
+                }
+            } else {
+                return NULL;
+            }
+        } else if (elem->key == index || (is_map_py_obj && py_obj_equal(elem->key, index))) {
+            // found it
+            if (add_if_not_found) {
+                elem->key = index;
+            }
+            return elem;
+        } else {
+            // not yet found, keep searching in this table
+            pos = (pos + 1) % map->alloc;
+        }
+    }
+}
+
+py_map_elem_t* py_qstr_map_lookup(py_map_t *map, qstr index, bool add_if_not_found) {
+    py_obj_t o = (py_obj_t)(machine_uint_t)index;
+    return py_map_lookup_helper(map, o, add_if_not_found);
+}
+
+py_map_elem_t* py_map_lookup(py_obj_t o, py_obj_t index, bool add_if_not_found) {
+    assert(IS_O(o, O_MAP));
+    return py_map_lookup_helper(&((py_obj_base_t *)o)->u_map, index, add_if_not_found);
+}
+
+static bool fit_small_int(py_small_int_t o) {
+    return true;
+}
+
+py_obj_t py_obj_new_const(const char *id) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_CONST;
+    o->id = id;
+    return (py_obj_t)o;
+}
+
+py_obj_t py_obj_new_str(qstr qstr) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_STR;
+    o->u_str = qstr;
+    return (py_obj_t)o;
+}
+
+#ifdef PY_FLOAT
+py_obj_t py_obj_new_float(float_t val) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_FLOAT;
+    o->flt = val;
+    return (py_obj_t)o;
+}
+#endif
+
+py_obj_t list_append(py_obj_t self_in, py_obj_t arg) {
+    assert(IS_O(self_in, O_LIST));
+    py_obj_base_t *self = self_in;
+    if (self->u_list.len >= self->u_list.alloc) {
+        self->u_list.alloc *= 2;
+        self->u_list.items = m_renew(py_obj_t, self->u_list.items, self->u_list.alloc);
+    }
+    self->u_list.items[self->u_list.len++] = arg;
+    return arg;
+}
+
+static qstr q_append;
+static qstr q_print;
+static qstr q_len;
+static qstr q___build_class__;
+
+typedef enum {
+    PY_CODE_NATIVE,
+    PY_CODE_BYTE,
+} py_code_kind_t;
+
+typedef struct _py_code_t {
+    py_code_kind_t kind;
+    int n_args;
+    union {
+        struct {
+            py_fun_t fun;
+        } u_native;
+        struct {
+            byte *code;
+            uint len;
+        } u_byte;
+    };
+} py_code_t;
+
+static int next_unique_code_id;
+static py_code_t *unique_codes;
+
+py_obj_t fun_list_append;
+
+py_obj_t py_builtin_print(py_obj_t o) {
+    if (IS_O(o, O_STR)) {
+        // special case, print string raw
+        printf("%s\n", qstr_str(((py_obj_base_t*)o)->u_str));
+    } else {
+        // print the object Python style
+        py_obj_print(o);
+        printf("\n");
+    }
+    return py_const_none;
+}
+
+py_obj_t py_builtin_len(py_obj_t o_in) {
+    py_small_int_t len = 0;
+    if (IS_O(o_in, O_LIST)) {
+        py_obj_base_t *o = o_in;
+        len = o->u_list.len;
+    } else if (IS_O(o_in, O_MAP)) {
+        py_obj_base_t *o = o_in;
+        len = o->u_map.used;
+    } else {
+        assert(0);
+    }
+    return TO_SMALL_INT(len);
+}
+
+py_obj_t py_builtin___build_class__(py_obj_t o1, py_obj_t o2) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_CLASS;
+    o->u_class.map = py_map_new(MAP_QSTR, 0);
+    return o;
+}
+
+FILE *fp_native = NULL;
+
+void rt_init() {
+    q_append = qstr_from_str_static("append");
+    q_print = qstr_from_str_static("print");
+    q_len = qstr_from_str_static("len");
+    q___build_class__ = qstr_from_str_static("__build_class__");
+
+    py_const_none = py_obj_new_const("None");
+    py_const_false = py_obj_new_const("False");
+    py_const_true = py_obj_new_const("True");
+
+    py_map_init(&map_name, MAP_QSTR, 0);
+
+    py_map_init(&map_builtins, MAP_QSTR, 3);
+    py_qstr_map_lookup(&map_builtins, q_print, true)->value = rt_make_function_1(py_builtin_print);
+    py_qstr_map_lookup(&map_builtins, q_len, true)->value = rt_make_function_1(py_builtin_len);
+    py_qstr_map_lookup(&map_builtins, q___build_class__, true)->value = rt_make_function_2(py_builtin___build_class__);
+
+    next_unique_code_id = 1;
+    unique_codes = NULL;
+
+    fun_list_append = rt_make_function_2(list_append);
+
+    fp_native = fopen("out-native", "wb");
+}
+
+void rt_deinit() {
+    if (fp_native != NULL) {
+        fclose(fp_native);
+    }
+}
+
+int rt_get_new_unique_code_id() {
+    return next_unique_code_id++;
+}
+
+void rt_assign_native_code(int unique_code_id, py_fun_t fun, uint len, int n_args) {
+    if (unique_codes == NULL) {
+        unique_codes = m_new(py_code_t, next_unique_code_id);
+    }
+    assert(unique_code_id < next_unique_code_id);
+    unique_codes[unique_code_id].kind = PY_CODE_NATIVE;
+    unique_codes[unique_code_id].n_args = n_args;
+    unique_codes[unique_code_id].u_native.fun = fun;
+
+    DEBUG_printf("assign native code: id=%d fun=%p len=%u n_args=%d\n", unique_code_id, fun, len, n_args);
+    byte *fun_data = (byte*)(((machine_uint_t)fun) & (~1)); // need to clear lower bit in case it's thumb code
+    for (int i = 0; i < 128 && i < len; i++) {
+        if (i > 0 && i % 16 == 0) {
+            DEBUG_printf("\n");
+        }
+        DEBUG_printf(" %02x", fun_data[i]);
+    }
+    DEBUG_printf("\n");
+
+    if (fp_native != NULL) {
+        fwrite(fun_data, len, 1, fp_native);
+    }
+}
+
+void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args) {
+    if (unique_codes == NULL) {
+        unique_codes = m_new(py_code_t, next_unique_code_id);
+    }
+    assert(unique_code_id < next_unique_code_id);
+    unique_codes[unique_code_id].kind = PY_CODE_BYTE;
+    unique_codes[unique_code_id].n_args = n_args;
+    unique_codes[unique_code_id].u_byte.code = code;
+    unique_codes[unique_code_id].u_byte.len = len;
+
+    DEBUG_printf("assign byte code: id=%d code=%p len=%u n_args=%d\n", unique_code_id, code, len, n_args);
+}
+
+const char *py_obj_get_type_str(py_obj_t o_in) {
+    if (IS_SMALL_INT(o_in)) {
+        return "int";
+    } else {
+        py_obj_base_t *o = o_in;
+        switch (o->kind) {
+            case O_CONST:
+                if (o == py_const_none) {
+                    return "NoneType";
+                } else {
+                    return "bool";
+                }
+            case O_STR:
+                return "str";
+#ifdef PY_FLOAT
+            case O_FLOAT:
+                return "float";
+#endif
+            case O_LIST:
+                return "list";
+            case O_SET:
+                return "set";
+            case O_MAP:
+                return "dict";
+            default:
+                assert(0);
+                return "UnknownType";
+        }
+    }
+}
+
+void py_obj_print(py_obj_t o_in) {
+    if (IS_SMALL_INT(o_in)) {
+        printf("%d", (int)FROM_SMALL_INT(o_in));
+    } else {
+        py_obj_base_t *o = o_in;
+        switch (o->kind) {
+            case O_CONST:
+                printf("%s", o->id);
+                break;
+            case O_STR:
+                // TODO need to escape chars etc
+                printf("'%s'", qstr_str(o->u_str));
+                break;
+#ifdef PY_FLOAT
+            case O_FLOAT:
+                printf("%f", o->flt);
+                break;
+#endif
+            case O_LIST:
+                printf("[");
+                for (int i = 0; i < o->u_list.len; i++) {
+                    if (i > 0) {
+                        printf(", ");
+                    }
+                    py_obj_print(o->u_list.items[i]);
+                }
+                printf("]");
+                break;
+            case O_SET:
+            {
+                bool first = true;
+                printf("{");
+                for (int i = 0; i < o->u_set.alloc; i++) {
+                    if (o->u_set.table[i] != NULL) {
+                        if (!first) {
+                            printf(", ");
+                        }
+                        first = false;
+                        py_obj_print(o->u_set.table[i]);
+                    }
+                }
+                printf("}");
+                break;
+            }
+            case O_MAP:
+            {
+                bool first = true;
+                printf("{");
+                for (int i = 0; i < o->u_map.alloc; i++) {
+                    if (o->u_map.table[i].key != NULL) {
+                        if (!first) {
+                            printf(", ");
+                        }
+                        first = false;
+                        py_obj_print(o->u_map.table[i].key);
+                        printf(": ");
+                        py_obj_print(o->u_map.table[i].value);
+                    }
+                }
+                printf("}");
+                break;
+            }
+            default:
+                assert(0);
+        }
+    }
+}
+
+int rt_is_true(py_obj_t arg) {
+    DEBUG_OP_printf("is true %p\n", arg);
+    if (IS_SMALL_INT(arg)) {
+        if (FROM_SMALL_INT(arg) == 0) {
+            return 0;
+        } else {
+            return 1;
+        }
+    } else if (arg == py_const_none) {
+        return 0;
+    } else if (arg == py_const_false) {
+        return 0;
+    } else if (arg == py_const_true) {
+        return 1;
+    } else {
+        assert(0);
+        return 0;
+    }
+}
+
+int rt_get_int(py_obj_t arg) {
+    if (IS_SMALL_INT(arg)) {
+        return FROM_SMALL_INT(arg);
+    } else {
+        assert(0);
+        return 0;
+    }
+}
+
+py_obj_t rt_load_const_str(qstr qstr) {
+    DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
+    return py_obj_new_str(qstr);
+}
+
+py_obj_t rt_load_name(qstr qstr) {
+    // logic: search locals, globals, builtins
+    DEBUG_OP_printf("load %s\n", qstr_str(qstr));
+    py_map_elem_t *elem = py_qstr_map_lookup(&map_name, qstr, false);
+    if (elem == NULL) {
+        elem = py_qstr_map_lookup(&map_builtins, qstr, false);
+        if (elem == NULL) {
+            printf("name doesn't exist: %s\n", qstr_str(qstr));
+            assert(0);
+        }
+    }
+    return elem->value;
+}
+
+py_obj_t rt_load_global(qstr qstr) {
+    return rt_load_name(qstr); // TODO
+}
+
+py_obj_t rt_load_build_class() {
+    DEBUG_OP_printf("load_build_class\n");
+    py_map_elem_t *elem = py_qstr_map_lookup(&map_builtins, q___build_class__, false);
+    if (elem == NULL) {
+        printf("name doesn't exist: __build_class__\n");
+        assert(0);
+    }
+    return elem->value;
+}
+
+void rt_store_name(qstr qstr, py_obj_t obj) {
+    DEBUG_OP_printf("store %s <- %p\n", qstr_str(qstr), obj);
+    py_qstr_map_lookup(&map_name, qstr, true)->value = obj;
+}
+
+py_obj_t rt_unary_op(int op, py_obj_t arg) {
+    assert(0);
+    return py_const_none;
+}
+
+py_obj_t rt_binary_op(int op, py_obj_t lhs, py_obj_t rhs) {
+    DEBUG_OP_printf("binary %d %p %p\n", op, lhs, rhs);
+    if (op == RT_BINARY_OP_SUBSCR) {
+        if (IS_O(lhs, O_LIST) && IS_SMALL_INT(rhs)) {
+            return ((py_obj_base_t*)lhs)->u_list.items[FROM_SMALL_INT(rhs)];
+        } else {
+            assert(0);
+        }
+    } else if (IS_SMALL_INT(lhs) && IS_SMALL_INT(rhs)) {
+        py_small_int_t val;
+        switch (op) {
+            case RT_BINARY_OP_ADD:
+            case RT_BINARY_OP_INPLACE_ADD: val = FROM_SMALL_INT(lhs) + FROM_SMALL_INT(rhs); break;
+            case RT_BINARY_OP_SUBTRACT: val = FROM_SMALL_INT(lhs) - FROM_SMALL_INT(rhs); break;
+            case RT_BINARY_OP_MULTIPLY: val = FROM_SMALL_INT(lhs) * FROM_SMALL_INT(rhs); break;
+            case RT_BINARY_OP_FLOOR_DIVIDE: val = FROM_SMALL_INT(lhs) / FROM_SMALL_INT(rhs); break;
+#ifdef PY_FLOAT
+            case RT_BINARY_OP_TRUE_DIVIDE: return py_obj_new_float((float_t)FROM_SMALL_INT(lhs) / (float_t)FROM_SMALL_INT(rhs));
+#endif
+            default: printf("%d\n", op); assert(0); val = 0;
+        }
+        if (fit_small_int(val)) {
+            return TO_SMALL_INT(val);
+        }
+    } else if (IS_O(lhs, O_STR) && IS_O(rhs, O_STR)) {
+        const char *lhs_str = qstr_str(((py_obj_base_t*)lhs)->u_str);
+        const char *rhs_str = qstr_str(((py_obj_base_t*)rhs)->u_str);
+        char *val;
+        switch (op) {
+            case RT_BINARY_OP_ADD:
+            case RT_BINARY_OP_INPLACE_ADD: val = m_new(char, strlen(lhs_str) + strlen(rhs_str) + 1); strcpy(val, lhs_str); strcat(val, rhs_str); break;
+            default: printf("%d\n", op); assert(0); val = NULL;
+        }
+        return py_obj_new_str(qstr_from_str_take(val));
+    }
+    assert(0);
+    return py_const_none;
+}
+
+py_obj_t rt_compare_op(int op, py_obj_t lhs, py_obj_t rhs) {
+    DEBUG_OP_printf("compare %d %p %p\n", op, lhs, rhs);
+    if (IS_SMALL_INT(lhs) && IS_SMALL_INT(rhs)) {
+        int cmp;
+        switch (op) {
+            case RT_COMPARE_OP_LESS: cmp = FROM_SMALL_INT(lhs) < FROM_SMALL_INT(rhs); break;
+            case RT_COMPARE_OP_MORE: cmp = FROM_SMALL_INT(lhs) > FROM_SMALL_INT(rhs); break;
+            default: assert(0); cmp = 0;
+        }
+        if (cmp) {
+            return py_const_true;
+        } else {
+            return py_const_false;
+        }
+    }
+    assert(0);
+    return py_const_none;
+}
+
+py_obj_t rt_make_function_from_id(int unique_code_id) {
+    if (unique_code_id >= next_unique_code_id) {
+        // illegal code id
+        return py_const_none;
+    }
+    py_code_t *c = &unique_codes[unique_code_id];
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    switch (c->kind) {
+        case PY_CODE_NATIVE:
+            switch (c->n_args) {
+                case 0: o->kind = O_FUN_0; break;
+                case 1: o->kind = O_FUN_1; break;
+                case 2: o->kind = O_FUN_2; break;
+                default: assert(0);
+            }
+            o->u_fun.fun = c->u_native.fun;
+            break;
+        case PY_CODE_BYTE:
+            o->kind = O_FUN_BC;
+            o->u_fun_bc.code = c->u_byte.code;
+            o->u_fun_bc.len = c->u_byte.len;
+            o->u_fun_bc.n_args = c->n_args;
+            break;
+        default:
+            assert(0);
+    }
+    return o;
+}
+
+py_obj_t rt_make_function_0(py_fun_0_t fun) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_FUN_0;
+    o->u_fun.fun = fun;
+    return o;
+}
+
+py_obj_t rt_make_function_1(py_fun_1_t fun) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_FUN_1;
+    o->u_fun.fun = fun;
+    return o;
+}
+
+py_obj_t rt_make_function_2(py_fun_2_t fun) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_FUN_2;
+    o->u_fun.fun = fun;
+    return o;
+}
+
+py_obj_t rt_make_function(int n_args, py_fun_t code) {
+    // assumes code is a pointer to a py_fun_t (i think this is safe...)
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_FUN_N;
+    o->u_fun.fun = code;
+    o->u_fun.n_args = n_args;
+    return o;
+}
+
+py_obj_t rt_call_function_0(py_obj_t fun) {
+    if (IS_O(fun, O_FUN_0)) {
+        py_obj_base_t *o = fun;
+        DEBUG_OP_printf("calling native %p...\n", o->u_fun.fun);
+        return ((py_fun_0_t)o->u_fun.fun)();
+    } else if (IS_O(fun, O_FUN_BC)) {
+        py_obj_base_t *o = fun;
+        assert(o->u_fun_bc.n_args == 0);
+        DEBUG_OP_printf("calling byte code %p...\n", o->u_fun_bc.code);
+        return py_execute_byte_code(o->u_fun_bc.code, o->u_fun_bc.len, NULL, 0);
+    } else {
+        printf("fun0:%p\n", fun);
+        assert(0);
+        return py_const_none;
+    }
+}
+
+py_obj_t rt_call_function_1(py_obj_t fun, py_obj_t arg) {
+    if (IS_O(fun, O_FUN_1)) {
+        py_obj_base_t *o = fun;
+        DEBUG_OP_printf("calling native %p...\n", o->u_fun.fun);
+        return ((py_fun_1_t)o->u_fun.fun)(arg);
+    } else if (IS_O(fun, O_FUN_BC)) {
+        py_obj_base_t *o = fun;
+        assert(o->u_fun_bc.n_args == 1);
+        DEBUG_OP_printf("calling byte code %p...\n", o->u_fun_bc.code);
+        return py_execute_byte_code(o->u_fun_bc.code, o->u_fun_bc.len, &arg, 1);
+    } else if (IS_O(fun, O_BOUND_METH)) {
+        py_obj_base_t *o = fun;
+        return rt_call_function_2(o->u_bound_meth.meth, o->u_bound_meth.self, arg);
+    } else {
+        printf("fun1:%p\n", fun);
+        assert(0);
+        return py_const_none;
+    }
+}
+
+py_obj_t rt_call_function_2(py_obj_t fun, py_obj_t arg1, py_obj_t arg2) {
+    if (IS_O(fun, O_FUN_2)) {
+        py_obj_base_t *o = fun;
+        DEBUG_OP_printf("calling native %p...\n", o->u_fun.fun);
+        return ((py_fun_2_t)o->u_fun.fun)(arg1, arg2);
+    } else if (IS_O(fun, O_FUN_BC)) {
+        py_obj_base_t *o = fun;
+        assert(o->u_fun_bc.n_args == 2);
+        DEBUG_OP_printf("calling byte code %p...\n", o->u_fun_bc.code);
+        py_obj_t args[2];
+        args[0] = arg1;
+        args[1] = arg2;
+        return py_execute_byte_code(o->u_fun_bc.code, o->u_fun_bc.len, &args[0], 2);
+    } else {
+        assert(0);
+        return py_const_none;
+    }
+}
+
+py_obj_t rt_call_method_1(py_obj_t fun, py_obj_t self) {
+    DEBUG_OP_printf("call method %p %p\n", fun, self);
+    if (self == NULL) {
+        return rt_call_function_0(fun);
+    } else {
+        return rt_call_function_1(fun, self);
+    }
+}
+
+py_obj_t rt_call_method_2(py_obj_t fun, py_obj_t self, py_obj_t arg) {
+    DEBUG_OP_printf("call method %p %p %p\n", fun, self, arg);
+    if (self == NULL) {
+        return rt_call_function_1(fun, arg);
+    } else {
+        return rt_call_function_2(fun, self, arg);
+    }
+}
+
+// items are in reverse order
+py_obj_t rt_build_list(int n_args, py_obj_t *items) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_LIST;
+    o->u_list.alloc = n_args;
+    if (o->u_list.alloc < 4) {
+        o->u_list.alloc = 4;
+    }
+    o->u_list.len = n_args;
+    o->u_list.items = m_new(py_obj_t, o->u_list.alloc);
+    for (int i = 0; i < n_args; i++) {
+        o->u_list.items[i] = items[n_args - i - 1];
+    }
+    return o;
+}
+
+py_obj_t py_set_lookup(py_obj_t o_in, py_obj_t index, bool add_if_not_found) {
+    assert(IS_O(o_in, O_SET));
+    py_obj_base_t *o = o_in;
+    int hash = py_obj_hash(index);
+    int pos = hash % o->u_set.alloc;
+    for (;;) {
+        py_obj_t elem = o->u_set.table[pos];
+        if (elem == NULL) {
+            // not in table
+            if (add_if_not_found) {
+                if (o->u_set.used + 1 >= o->u_set.alloc) {
+                    // not enough room in table, rehash it
+                    int old_alloc = o->u_set.alloc;
+                    py_obj_t *old_table = o->u_set.table;
+                    o->u_set.alloc = get_doubling_prime_greater_or_equal_to(o->u_set.alloc + 1);
+                    o->u_set.used = 0;
+                    o->u_set.table = m_new(py_obj_t, o->u_set.alloc);
+                    for (int i = 0; i < old_alloc; i++) {
+                        if (old_table[i] != NULL) {
+                            py_set_lookup(o, old_table[i], true);
+                        }
+                    }
+                    m_free(old_table);
+                    // restart the search for the new element
+                    pos = hash % o->u_set.alloc;
+                } else {
+                    o->u_set.used += 1;
+                    o->u_set.table[pos] = index;
+                    return index;
+                }
+            } else {
+                return NULL;
+            }
+        } else if (py_obj_equal(elem, index)) {
+            // found it
+            return elem;
+        } else {
+            // not yet found, keep searching in this table
+            pos = (pos + 1) % o->u_set.alloc;
+        }
+    }
+}
+
+py_obj_t rt_build_set(int n_args, py_obj_t *items) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_SET;
+    o->u_set.alloc = get_doubling_prime_greater_or_equal_to(n_args + 1);
+    o->u_set.used = 0;
+    o->u_set.table = m_new(py_obj_t, o->u_set.alloc);
+    for (int i = 0; i < o->u_set.alloc; i++) {
+        o->u_set.table[i] = NULL;
+    }
+    for (int i = 0; i < n_args; i++) {
+        py_set_lookup(o, items[i], true);
+    }
+    return o;
+}
+
+py_obj_t rt_build_map(int n_args) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_MAP;
+    py_map_init(&o->u_map, MAP_PY_OBJ, n_args);
+    return o;
+}
+
+py_obj_t rt_store_map(py_obj_t map, py_obj_t key, py_obj_t value) {
+    assert(IS_O(map, O_MAP)); // should always be
+    py_map_lookup(map, key, true)->value = value;
+    return map;
+}
+
+void rt_store_subscr(py_obj_t base, py_obj_t index, py_obj_t value) {
+    if (IS_O(base, O_LIST) && IS_SMALL_INT(index)) {
+        // list store
+        py_obj_base_t *o = base;
+        int idx = FROM_SMALL_INT(index);
+        if (idx < 0) {
+            idx += o->u_list.len;
+        }
+        if (0 <= idx && idx < o->u_list.len) {
+            o->u_list.items[idx] = value;
+        } else {
+            assert(0);
+        }
+    } else if (IS_O(base, O_MAP)) {
+        // map store
+        py_map_lookup(base, index, true)->value = value;
+    } else {
+        assert(0);
+    }
+}
+
+py_obj_t build_bound_method(py_obj_t self, py_obj_t meth) {
+    py_obj_base_t *o = m_new(py_obj_base_t, 1);
+    o->kind = O_BOUND_METH;
+    o->u_bound_meth.meth = meth;
+    o->u_bound_meth.self = self;
+    return o;
+}
+
+py_obj_t rt_load_attr(py_obj_t base, qstr attr) {
+    DEBUG_OP_printf("load %s\n", qstr_str(attr));
+    if (IS_O(base, O_LIST) && attr == q_append) {
+        return build_bound_method(base, fun_list_append);
+    } else if (IS_O(base, O_CLASS)) {
+        py_obj_base_t *o = base;
+        py_map_elem_t *elem = py_qstr_map_lookup(o->u_class.map, attr, false);
+        if (elem == NULL) {
+            printf("Nope! %s\n", qstr_str(attr));
+            assert(0);
+        }
+        return elem->value;
+    } else {
+        printf("AttributeError: '%s' object has no attribute '%s'\n", py_obj_get_type_str(base), qstr_str(attr));
+        assert(0);
+        return py_const_none;
+    }
+}
+
+void rt_load_method(py_obj_t base, qstr attr, py_obj_t *dest) {
+    DEBUG_OP_printf("load method %s\n", qstr_str(attr));
+    if (IS_O(base, O_LIST) && attr == q_append) {
+        dest[1] = fun_list_append;
+        dest[0] = base;
+    } else {
+        dest[1] = rt_load_attr(base, attr);
+        dest[0] = NULL;
+    }
+}
+
+void *rt_fun_table[RT_F_NUMBER_OF] = {
+    rt_load_const_str,
+    rt_load_name,
+    rt_load_global,
+    rt_load_attr,
+    rt_load_method,
+    rt_store_name,
+    rt_store_subscr,
+    rt_is_true,
+    rt_unary_op,
+    rt_build_list,
+    rt_build_map,
+    rt_store_map,
+    rt_build_set,
+    rt_make_function_from_id,
+    rt_call_function_0,
+    rt_call_function_1,
+    rt_call_function_2,
+    rt_call_method_1,
+    rt_call_method_2,
+    rt_binary_op,
+    rt_compare_op,
+};
+
+/*
+void rt_f_vector(rt_fun_kind_t fun_kind) {
+    (rt_f_table[fun_kind])();
+}
+*/
diff --git a/py/runtime.h b/py/runtime.h
new file mode 100644
index 0000000..4c842b2
--- /dev/null
+++ b/py/runtime.h
@@ -0,0 +1,121 @@
+typedef enum {
+    RT_UNARY_OP_NOT,
+    RT_UNARY_OP_POSITIVE,
+    RT_UNARY_OP_NEGATIVE,
+    RT_UNARY_OP_INVERT,
+} rt_unary_op_t;
+
+typedef enum {
+    RT_BINARY_OP_SUBSCR,
+    RT_BINARY_OP_OR,
+    RT_BINARY_OP_XOR,
+    RT_BINARY_OP_AND,
+    RT_BINARY_OP_LSHIFT,
+    RT_BINARY_OP_RSHIFT,
+    RT_BINARY_OP_ADD,
+    RT_BINARY_OP_SUBTRACT,
+    RT_BINARY_OP_MULTIPLY,
+    RT_BINARY_OP_FLOOR_DIVIDE,
+    RT_BINARY_OP_TRUE_DIVIDE,
+    RT_BINARY_OP_MODULO,
+    RT_BINARY_OP_POWER,
+    RT_BINARY_OP_INPLACE_OR,
+    RT_BINARY_OP_INPLACE_XOR,
+    RT_BINARY_OP_INPLACE_AND,
+    RT_BINARY_OP_INPLACE_LSHIFT,
+    RT_BINARY_OP_INPLACE_RSHIFT,
+    RT_BINARY_OP_INPLACE_ADD,
+    RT_BINARY_OP_INPLACE_SUBTRACT,
+    RT_BINARY_OP_INPLACE_MULTIPLY,
+    RT_BINARY_OP_INPLACE_FLOOR_DIVIDE,
+    RT_BINARY_OP_INPLACE_TRUE_DIVIDE,
+    RT_BINARY_OP_INPLACE_MODULO,
+    RT_BINARY_OP_INPLACE_POWER,
+} rt_binary_op_t;
+
+typedef enum {
+    RT_COMPARE_OP_LESS,
+    RT_COMPARE_OP_MORE,
+    RT_COMPARE_OP_EQUAL,
+    RT_COMPARE_OP_LESS_EQUAL,
+    RT_COMPARE_OP_MORE_EQUAL,
+    RT_COMPARE_OP_NOT_EQUAL,
+    RT_COMPARE_OP_IN,
+    RT_COMPARE_OP_NOT_IN,
+    RT_COMPARE_OP_IS,
+    RT_COMPARE_OP_IS_NOT,
+    RT_COMPARE_OP_EXCEPTION_MATCH,
+} rt_compare_op_t;
+
+typedef enum {
+    RT_F_LOAD_CONST_STR = 0,
+    RT_F_LOAD_NAME,
+    RT_F_LOAD_GLOBAL,
+    RT_F_LOAD_ATTR,
+    RT_F_LOAD_METHOD,
+    RT_F_STORE_NAME,
+    RT_F_STORE_SUBSCR,
+    RT_F_IS_TRUE,
+    RT_F_UNARY_OP,
+    RT_F_BUILD_LIST,
+    RT_F_BUILD_MAP,
+    RT_F_STORE_MAP,
+    RT_F_BUILD_SET,
+    RT_F_MAKE_FUNCTION_FROM_ID,
+    RT_F_CALL_FUNCTION_0,
+    RT_F_CALL_FUNCTION_1,
+    RT_F_CALL_FUNCTION_2,
+    RT_F_CALL_METHOD_1,
+    RT_F_CALL_METHOD_2,
+    RT_F_BINARY_OP,
+    RT_F_COMPARE_OP,
+    RT_F_NUMBER_OF,
+} rt_fun_kind_t;
+
+extern void *rt_fun_table[RT_F_NUMBER_OF];
+
+typedef machine_ptr_t py_obj_t; // must be of pointer size
+typedef py_obj_t (*py_fun_0_t)();
+typedef py_obj_t (*py_fun_1_t)(py_obj_t);
+typedef py_obj_t (*py_fun_2_t)(py_obj_t, py_obj_t);
+typedef py_obj_t (*py_fun_t)();
+
+extern py_obj_t py_const_none;
+extern py_obj_t py_const_false;
+extern py_obj_t py_const_true;
+
+void rt_init();
+void rt_deinit();
+int rt_get_new_unique_code_id();
+void rt_assign_native_code(int unique_code_id, py_fun_t f, uint len, int n_args);
+void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args);
+py_fun_t rt_get_code(qstr id);
+void py_obj_print(py_obj_t o);
+int rt_is_true(py_obj_t arg);
+int rt_get_int(py_obj_t arg);
+py_obj_t rt_load_const_str(qstr qstr);
+//py_obj_t rt_load_const_code(qstr qstr);
+py_obj_t rt_load_name(qstr qstr);
+py_obj_t rt_load_global(qstr qstr);
+py_obj_t rt_load_build_class();
+void rt_store_name(qstr qstr, py_obj_t obj);
+py_obj_t rt_unary_op(int op, py_obj_t arg);
+py_obj_t rt_binary_op(int op, py_obj_t lhs, py_obj_t rhs);
+py_obj_t rt_compare_op(int op, py_obj_t lhs, py_obj_t rhs);
+py_obj_t rt_make_function_from_id(int unique_code_id);
+py_obj_t rt_make_function_0(py_fun_0_t f);
+py_obj_t rt_make_function_1(py_fun_1_t f);
+py_obj_t rt_make_function_2(py_fun_2_t f);
+py_obj_t rt_make_function(int n_args, py_fun_t code);
+py_obj_t rt_call_function_0(py_obj_t fun);
+py_obj_t rt_call_function_1(py_obj_t fun, py_obj_t arg);
+py_obj_t rt_call_function_2(py_obj_t fun, py_obj_t arg1, py_obj_t arg2);
+py_obj_t rt_call_method_1(py_obj_t fun, py_obj_t self);
+py_obj_t rt_call_method_2(py_obj_t fun, py_obj_t self, py_obj_t arg);
+py_obj_t rt_build_list(int n_args, py_obj_t *items);
+py_obj_t rt_build_map(int n_args);
+py_obj_t rt_store_map(py_obj_t map, py_obj_t key, py_obj_t value);
+py_obj_t rt_build_set(int n_args, py_obj_t *items);
+void rt_store_subscr(py_obj_t base, py_obj_t index, py_obj_t val);
+py_obj_t rt_load_attr(py_obj_t base, qstr attr);
+void rt_load_method(py_obj_t base, qstr attr, py_obj_t *dest);
diff --git a/py/scope.c b/py/scope.c
new file mode 100644
index 0000000..a715b2b
--- /dev/null
+++ b/py/scope.c
@@ -0,0 +1,218 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "parse.h"
+#include "scope.h"
+
+scope_t *scope_new(scope_kind_t kind, py_parse_node_t pn) {
+    scope_t *scope = m_new(scope_t, 1);
+    scope->kind = kind;
+    scope->parent = NULL;
+    scope->next = NULL;
+    scope->pn = pn;
+    switch (kind) {
+        case SCOPE_MODULE:
+            scope->simple_name = 0;
+            break;
+        case SCOPE_FUNCTION:
+        case SCOPE_CLASS:
+            assert(PY_PARSE_NODE_IS_STRUCT(pn));
+            scope->simple_name = PY_PARSE_NODE_LEAF_ARG(((py_parse_node_struct_t*)pn)->nodes[0]);
+            break;
+        case SCOPE_LAMBDA:
+            scope->simple_name = qstr_from_str_static("<lambda>");
+            break;
+        case SCOPE_LIST_COMP:
+            scope->simple_name = qstr_from_str_static("<listcomp>");
+            break;
+        case SCOPE_DICT_COMP:
+            scope->simple_name = qstr_from_str_static("<dictcomp>");
+            break;
+        case SCOPE_SET_COMP:
+            scope->simple_name = qstr_from_str_static("<setcomp>");
+            break;
+        case SCOPE_GEN_EXPR:
+            scope->simple_name = qstr_from_str_static("<genexpr>");
+            break;
+        default:
+            assert(0);
+    }
+    scope->id_info_alloc = 8;
+    scope->id_info_len = 0;
+    scope->id_info = m_new(id_info_t, scope->id_info_alloc);
+
+    scope->flags = 0;
+    scope->num_params = 0;
+    /* not needed
+    scope->num_default_params = 0;
+    scope->num_dict_params = 0;
+    */
+    scope->num_locals = 0;
+    scope->unique_code_id = 0;
+
+    return scope;
+}
+
+id_info_t *scope_find_or_add_id(scope_t *scope, qstr qstr, bool *added) {
+    for (int i = 0; i < scope->id_info_len; i++) {
+        if (scope->id_info[i].qstr == qstr) {
+            *added = false;
+            return &scope->id_info[i];
+        }
+    }
+
+    // make sure we have enough memory
+    if (scope->id_info_len >= scope->id_info_alloc) {
+        scope->id_info_alloc *= 2;
+        scope->id_info = m_renew(id_info_t, scope->id_info, scope->id_info_alloc);
+    }
+
+    id_info_t *id_info;
+
+    {
+    /*
+    // just pick next slot in array
+    id_info = &scope->id_info[scope->id_info_len++];
+    */
+    }
+
+    {
+    // sort insert into id_info array, so we are equivalent to CPython (no other reason to do it)
+    scope->id_info_len += 1;
+    for (int i = scope->id_info_len - 1;; i--) {
+        if (i == 0 || strcmp(qstr_str(scope->id_info[i - 1].qstr), qstr_str(qstr)) < 0) {
+            id_info = &scope->id_info[i];
+            break;
+        } else {
+            scope->id_info[i] = scope->id_info[i - 1];
+        }
+    }
+    }
+
+    id_info->param = false;
+    id_info->kind = 0;
+    id_info->qstr = qstr;
+    *added = true;
+    return id_info;
+}
+
+id_info_t *scope_find(scope_t *scope, qstr qstr) {
+    for (int i = 0; i < scope->id_info_len; i++) {
+        if (scope->id_info[i].qstr == qstr) {
+            return &scope->id_info[i];
+        }
+    }
+    return NULL;
+}
+
+id_info_t *scope_find_global(scope_t *scope, qstr qstr) {
+    while (scope->parent != NULL) {
+        scope = scope->parent;
+    }
+    for (int i = 0; i < scope->id_info_len; i++) {
+        if (scope->id_info[i].qstr == qstr) {
+            return &scope->id_info[i];
+        }
+    }
+    return NULL;
+}
+
+id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr) {
+    if (scope->parent == NULL) {
+        return NULL;
+    }
+    for (scope_t *s = scope->parent; s->parent != NULL; s = s->parent) {
+        for (int i = 0; i < s->id_info_len; i++) {
+            if (s->id_info[i].qstr == qstr) {
+                return &s->id_info[i];
+            }
+        }
+    }
+    return NULL;
+}
+
+void scope_close_over_in_parents(scope_t *scope, qstr qstr) {
+    assert(scope->parent != NULL); // we should have at least 1 parent
+    for (scope_t *s = scope->parent; s->parent != NULL; s = s->parent) {
+        id_info_t *id = NULL;
+        for (int i = 0; i < s->id_info_len; i++) {
+            if (s->id_info[i].qstr == qstr) {
+                id = &s->id_info[i];
+                break;
+            }
+        }
+        if (id == NULL) {
+            // variable not declared in this scope, so declare it as free and keep searching parents
+            bool added;
+            id = scope_find_or_add_id(s, qstr, &added);
+            assert(added);
+            id->kind = ID_INFO_KIND_FREE;
+        } else {
+            // variable is declared in this scope, so finish
+            switch (id->kind) {
+                case ID_INFO_KIND_LOCAL: id->kind = ID_INFO_KIND_CELL; break; // variable local to this scope, close it over
+                case ID_INFO_KIND_FREE: break; // variable already closed over in a parent scope
+                case ID_INFO_KIND_CELL: break; // variable already closed over in this scope
+                default: assert(0); // TODO
+            }
+            return;
+        }
+    }
+    assert(0); // we should have found the variable in one of the parents
+}
+
+void scope_print_info(scope_t *s) {
+    if (s->kind == SCOPE_MODULE) {
+        printf("code <module>\n");
+    } else if (s->kind == SCOPE_LAMBDA) {
+        printf("code <lambda>\n");
+    } else if (s->kind == SCOPE_LIST_COMP) {
+        printf("code <listcomp>\n");
+    } else if (s->kind == SCOPE_DICT_COMP) {
+        printf("code <dictcomp>\n");
+    } else if (s->kind == SCOPE_SET_COMP) {
+        printf("code <setcomp>\n");
+    } else if (s->kind == SCOPE_GEN_EXPR) {
+        printf("code <genexpr>\n");
+    } else {
+        printf("code %s\n", qstr_str(s->simple_name));
+    }
+    /*
+    printf("var global:");
+    for (int i = 0; i < s->id_info_len; i++) {
+        if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
+            printf(" %s", qstr_str(s->id_info[i].qstr));
+        }
+    }
+    printf("\n");
+    printf("var name:");
+    for (int i = 0; i < s->id_info_len; i++) {
+        if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
+            printf(" %s", qstr_str(s->id_info[i].qstr));
+        }
+    }
+    printf("\n");
+    printf("var local:");
+    for (int i = 0; i < s->id_info_len; i++) {
+        if (s->id_info[i].kind == ID_INFO_KIND_LOCAL) {
+            printf(" %s", qstr_str(s->id_info[i].qstr));
+        }
+    }
+    printf("\n");
+    printf("var free:");
+    for (int i = 0; i < s->id_info_len; i++) {
+        if (s->id_info[i].kind == ID_INFO_KIND_FREE) {
+            printf(" %s", qstr_str(s->id_info[i].qstr));
+        }
+    }
+    printf("\n");
+    */
+    printf("     flags %04x\n", s->flags);
+    printf("     argcount %d\n", s->num_params);
+    printf("     nlocals %d\n", s->num_locals);
+    printf("     stacksize %d\n", s->stack_size);
+}
diff --git a/py/scope.h b/py/scope.h
new file mode 100644
index 0000000..2d620fb
--- /dev/null
+++ b/py/scope.h
@@ -0,0 +1,58 @@
+enum {
+    ID_INFO_KIND_GLOBAL_IMPLICIT,
+    ID_INFO_KIND_GLOBAL_EXPLICIT,
+    ID_INFO_KIND_LOCAL, // in a function f, written and only referenced by f
+    ID_INFO_KIND_CELL,  // in a function f, read/written by children of f
+    ID_INFO_KIND_FREE,  // in a function f, belongs to the parent of f
+};
+
+typedef struct _id_info_t {
+    bool param;
+    int kind;
+    qstr qstr;
+    int local_num; // when it's an ID_INFO_KIND_LOCAL this is the unique number of the local
+} id_info_t;
+
+// taken from python source, Include/code.h
+#define SCOPE_FLAG_OPTIMISED    0x0001
+#define SCOPE_FLAG_NEWLOCALS    0x0002
+#define SCOPE_FLAG_VARARGS      0x0004
+#define SCOPE_FLAG_VARKEYWORDS  0x0008
+#define SCOPE_FLAG_NESTED       0x0010
+#define SCOPE_FLAG_GENERATOR    0x0020
+/* The SCOPE_FLAG_NOFREE flag is set if there are no free or cell variables.
+   This information is redundant, but it allows a single flag test
+   to determine whether there is any extra work to be done when the
+   call frame is setup.
+*/
+#define SCOPE_FLAG_NOFREE       0x0040
+
+// scope is a "block" in Python parlance
+typedef enum { SCOPE_MODULE, SCOPE_FUNCTION, SCOPE_LAMBDA, SCOPE_LIST_COMP, SCOPE_DICT_COMP, SCOPE_SET_COMP, SCOPE_GEN_EXPR, SCOPE_CLASS } scope_kind_t;
+typedef struct _scope_t {
+    scope_kind_t kind;
+    struct _scope_t *parent;
+    struct _scope_t *next;
+    py_parse_node_t pn;
+    qstr simple_name;
+    int id_info_alloc;
+    int id_info_len;
+    id_info_t *id_info;
+    int flags;
+    int num_params;
+    /* not needed
+    int num_default_params;
+    int num_dict_params;
+    */
+    int num_locals;
+    int stack_size;
+    int unique_code_id;
+} scope_t;
+
+scope_t *scope_new(scope_kind_t kind, py_parse_node_t pn);
+id_info_t *scope_find_or_add_id(scope_t *scope, qstr qstr, bool *added);
+id_info_t *scope_find(scope_t *scope, qstr qstr);
+id_info_t *scope_find_global(scope_t *scope, qstr qstr);
+id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr);
+void scope_close_over_in_parents(scope_t *scope, qstr qstr);
+void scope_print_info(scope_t *s);