diff --git a/CMakeLists.txt b/CMakeLists.txt
index 05972b1..a652cbc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,13 +8,13 @@ add_compile_definitions(_POSIX_C_SOURCE=200112L)
 add_compile_definitions(_GNU_SOURCE)
 add_compile_options(-fno-trapping-math)
 
-add_executable(codegen_l1 src/l1/codegen/codegen.c)
-target_compile_definitions(codegen_l1
-    PRIVATE PROTOTYPE1_L1_CODEGEN_BOOTSTRAP_USE_CHICKEN_VECU8)
+#add_executable(codegen_l1 src/l1/codegen/codegen.c)
+#target_compile_definitions(codegen_l1
+#    PRIVATE PROTOTYPE1_L1_CODEGEN_BOOTSTRAP_USE_CHICKEN_VECU8)
+
+add_executable(0_test src/l1/tests/t0.c)
+add_executable(1_test src/l1/tests/t1.c)
 
-#add_executable(0_test src/l1/tests/t0.c)
-#add_executable(1_test src/l1/tests/t1.c)
-#
 #add_executable(codegen_l2 src/l2/codegen/codegen.c)
 #
 #add_executable(0_render_test src/l2/tests/r0/r0.c)
diff --git a/Makefile b/Makefile
index 196269e..72a3b8e 100644
--- a/Makefile
+++ b/Makefile
@@ -1,50 +1,64 @@
-#HEADERS := $(shell find src -type f -name '*.h')
+HEADERS_src_l1 := $(shell find src/l1 -type f -name '*.h')
+HEADERS_gen_l1 := $(shell find gen/l1 -type f -name '*.h') essence_gen_l1
+
+HEADERS_src_l2 := $(shell find src/l2 -type f -name '*.h')
+HEADERS_gen_l2 := $(shell find gen/l2 -type f -name '*.h') essence_gen_l2
+
+HEADERS_src_l3 := $(shell find src/l3 -type f -name '*.h')
 
 cflags := -Wall -Wextra -Werror=implicit-function-declaration -Werror=return-type --std=c99 -g -ggdb -O0 \
 				-fno-trapping-math -D_POSIX_C_SOURCE=200112L -D_GNU_SOURCE
-cc := 'gcc'
+cc := gcc
 
 wl_protocols := $(shell pkg-config --variable=pkgdatadir wayland-protocols)
 
-out/l1/codegen_l1: src/l1/codegen/codegen.c $(HEADERS)
-	mkdir -p out/l2
-	$(cc) $(cflags) -o $@ $<
+out/l1/codegen: src/l1/codegen/codegen.c $(HEADERS_src_l1)
+	mkdir -p out/l1
+	$(cc) $(cflags) -D PROTOTYPE1_L1_CODEGEN_BOOTSTRAP_USE_CHICKEN_VECU8 -o $@ $<
 
-out/l1/t0: src/l1/tests/t0.c $(HEADERS)
+.PHONY: essence_gen_l1
+essence_gen_l1: out/l1/codegen
+	mkdir -p gen
+	cd gen && ../out/l1/codegen
+
+
+out/l1/t0: src/l1/tests/t0.c $(HEADERS_gen_l1) $(HEADERS_src_l1)
 	mkdir -p out/l1
 	$(cc) $(cflags) -o $@ $<
 
-out/l1/t1: src/l1/tests/t1.c $(HEADERS)
+out/l1/t1: src/l1/tests/t1.c $(HEADERS_gen_l1) $(HEADERS_src_l1)
 	mkdir -p out/l1
 	$(cc) $(cflags) -o $@ $<
 
 
 
-out/l2/codegen_l2: src/l2/codegen/codegen.c $(HEADERS)
-	mkdir -p out/l2
-	$(cc) $(cflags) -o $@ $<
-
-gen/l_wl_protocols/xdg-shell-client.h: $(wl_protocols)/stable/xdg-shell/xdg-shell.xml
-	mkdir -p gen/l_wl_protocols
-	wayland-scanner client-header $< $@
-
-gen/l_wl_protocols/xdg-shell-private.c: $(wl_protocols)/stable/xdg-shell/xdg-shell.xml
-	mkdir -p gen/l_wl_protocols
-	wayland-scanner private-code $< $@
 
 
-
-out/l2/r0: src/l2/tests/r0/r0.c $(HEADERS)
-	mkdir -p out/l2
-	$(cc) $(cflags) -o $@ $< -lvulkan -lX11 -lm
-
-out/l2/r0: src/l2/tests/r0/r0_tex_init_prep.c $(HEADERS)
-	mkdir -p out/l2
-	$(cc) $(cflags) -o $@ $< -lm
-
-out/l2/r1: src/l2/tests/r1/r1.c $(HEADERS)
-	mkdir -p out/l2
-	$(cc) $(cflags) -o $@ $< gen/l_wl_protocols/xdg-shell-private.c -lwayland-client -lrt -lxkbcommon
+#out/l2/codegen_l2: src/l2/codegen/codegen.c $(HEADERS_src_l2) $(HEADERS_gen_l1) $(HEADERS_src_l1)
+#	mkdir -p out/l2
+#	$(cc) $(cflags) -o $@ $<
+#
+#gen/l_wl_protocols/xdg-shell-client.h: $(wl_protocols)/stable/xdg-shell/xdg-shell.xml
+#	mkdir -p gen/l_wl_protocols
+#	wayland-scanner client-header $< $@
+#
+#gen/l_wl_protocols/xdg-shell-private.c: $(wl_protocols)/stable/xdg-shell/xdg-shell.xml
+#	mkdir -p gen/l_wl_protocols
+#	wayland-scanner private-code $< $@
+#
+#
+#
+#out/l2/r0: src/l2/tests/r0/r0.c $(HEADERS_gen_l2) $(HEADERS_src_l2) $(HEADERS_gen_l1) $(HEADERS_src_l1)
+#	mkdir -p out/l2
+#	$(cc) $(cflags) -o $@ $< -lvulkan -lX11 -lm
+#
+#out/l2/r0: src/l2/tests/r0/r0_tex_init_prep.c $(HEADERS_gen_l2) $(HEADERS_src_l2) $(HEADERS_gen_l1) $(HEADERS_src_l1)
+#	mkdir -p out/l2
+#	$(cc) $(cflags) -o $@ $< -lm
+#
+#out/l2/r1: src/l2/tests/r1/r1.c $(HEADERS_gen_l2) $(HEADERS_src_l2) $(HEADERS_gen_l1) $(HEADERS_src_l1)
+#	mkdir -p out/l2
+#	$(cc) $(cflags) -o $@ $< gen/l_wl_protocols/xdg-shell-private.c -lwayland-client -lrt -lxkbcommon
 
 clean:
 	rm -rf gen out
diff --git a/src/l1/codegen/codegen.c b/src/l1/codegen/codegen.c
index 97ae445..4670a9c 100644
--- a/src/l1/codegen/codegen.c
+++ b/src/l1/codegen/codegen.c
@@ -2,40 +2,39 @@
 #include "../system/fsmanip.h"
 
 int main() {
-    VecU8 e = VecU8_fmt("%sA%%%s\n", cstr("AA"), cstr("BB"));
-    SpanU8_print(VecU8_to_SpanU8(&e));
-    VecU8_drop(e);
-    return 0;
     make_dir_nofail("l1");
     {
         VecU8 head = begin_header(cstr("PROTOTYPE1_L1_VECANDSPANANDOPTION_INT_PRIMITIVES_H"));
+        VecU8_append_span(&head, cstr("#include \"../../src/l1/core/util.h\"\n\n"));
         SpanU8 T[4] = {cstr("U8"), cstr("U16"), cstr("U32"), cstr("U64")};
         for (size_t i = 0; i < ARRAY_SIZE(T); i++) {
             VecU8_append_vec(&head, generate_util_templates_instantiation(T[i], (util_templates_instantiation_options){
-                .t_integer = true, .t_primitive = true, .vec = true, .vec_equal = true, .span = true, .mut_span = true,
-                .collab_vec_span = true, .option = true
+                .t_integer = true, .t_primitive = true, .vec = true, .vec_extended = true,
+                .vec_equal = true, .span = true, .span_extended = true, .mut_span = true,
+                .collab_vec_span = true, .collab_vec_span_extended = true, .option = true
             }));
         }
         finish_header(head, "l1/VecAndSpanAndOption_int_primitives.h");
     }
     {
         VecU8 head = begin_header(cstr("PROTOTYPE1_L1_VECANDSPAN_VEC_INT_PRIMITIVES_H"));
+        VecU8_append_span(&head, cstr("#include \"VecAndSpanAndOption_int_primitives.h\"\n\n"));
         SpanU8 T[4] = {cstr("VecU8"), cstr("VecU16"), cstr("VecU32"), cstr("VecU64")};
         for (size_t i = 0; i < ARRAY_SIZE(T); i++) {
             VecU8_append_vec(&head, generate_util_templates_instantiation(T[i], (util_templates_instantiation_options){
-                .t_integer = true, .t_primitive = true, .vec = true, .vec_equal = true, .span = true, .mut_span = true,
-                .collab_vec_span = true, .option = true
+                .vec = true, .vec_extended = true, .span = true, .collab_vec_span = true, .vec_equal = true,
             }));
         }
         finish_header(head, "l1/VecAndSpan_Vec_int_primitives.h");
     }
     {
         VecU8 head = begin_header(cstr("PROTOTYPE1_L1_VECANDSPAN_SPAN_INT_PRIMITIVES_H"));
+        VecU8_append_span(&head, cstr("#include \"VecAndSpanAndOption_int_primitives.h\"\n\n"));
         SpanU8 T[4] = {cstr("VecU8")};
         for (size_t i = 0; i < ARRAY_SIZE(T); i++) {
             VecU8_append_vec(&head, generate_util_templates_instantiation(T[i], (util_templates_instantiation_options){
-                .t_integer = true, .t_primitive = true, .vec = true, .vec_equal = true, .span = true, .mut_span = true,
-                .collab_vec_span = true, .option = true
+                .t_primitive = true, .vec = true, .vec_equal = true, .span = true, .mut_span = true,
+                .collab_vec_span = true,
             }));
         }
         finish_header(head, "l1/VecAndSpan_Span_int_primitives.h");
diff --git a/src/l1/codegen/util_template_inst.h b/src/l1/codegen/util_template_inst.h
index dcb471a..c6ce7ab 100644
--- a/src/l1/codegen/util_template_inst.h
+++ b/src/l1/codegen/util_template_inst.h
@@ -9,10 +9,10 @@ NODISCARD VecU8 generate_VecT_struct_and_base_methods(SpanU8 T, bool primitive)
     SpanU8 VecT = VecU8_to_SpanU8(&g_VecT);
     VecU8 res = VecU8_fmt(
     "typedef struct {\n"
-    SPACE4 "T* buf;\n"
+    SPACE4 "%s* buf;\n"
     SPACE4 "size_t len;\n"
     SPACE4 "size_t capacity;\n"
-    "} %s\n\n", VecT);
+    "} %s;\n\n", T, VecT);
 
     VecU8_append_vec(&res, VecU8_fmt("#define %s_new() (%s){ 0 }\n\n", VecT, VecT));
 
@@ -23,11 +23,11 @@ NODISCARD VecU8 generate_VecT_struct_and_base_methods(SpanU8 T, bool primitive)
             SPACE4 SPACE4 "%s_drop(self.buf[i]);\n", T));
     }
     VecU8_append_vec(&res, VecU8_fmt(
-    SPACE4 "free(self->buf);\n"
+    SPACE4 "free(self.buf);\n"
     "}\n\n"));
 
     VecU8_append_vec(&res, VecU8_fmt(
-    "%s %s_new_reserved(size_t n) {\n"
+    "NODISCARD %s %s_new_reserved(size_t n) {\n"
     SPACE4 "return (%s){ .buf = safe_calloc(n, sizeof(%s)), .len = 0, .capacity = n };\n"
     "}\n\n", VecT, VecT, VecT, T));
 
@@ -44,30 +44,30 @@ NODISCARD VecU8 generate_VecT_struct_and_base_methods(SpanU8 T, bool primitive)
     "}\n\n", VecT, VecT, T, T));
 
     VecU8_append_vec(&res, VecU8_fmt(
-    "%s %s_mat(%s* self, size_t i) {\n"
+    "%s* %s_mat(%s* self, size_t i) {\n"
     SPACE4 "assert(i < self->len);\n"
     SPACE4 "return &self->buf[i];\n"
     "}\n\n", T, VecT, VecT));
 
     VecU8_append_vec(&res, VecU8_fmt(
-    "%s %s_at(const %s* self, size_t i) {\n"
+    "const %s* %s_at(const %s* self, size_t i) {\n"
     SPACE4 "assert(i < self->len);\n"
     SPACE4 "return &self->buf[i];\n"
     "}\n\n", T, VecT, VecT));
 
     VecU8_append_vec(&res, VecU8_fmt(
-    "%s %s_clone(const %s* self) {\n"
-    SPACE4 "%s res = (%s){.buf = safe_calloc(self->len, sizeof(%s)), .len = self->len, .capacity = self->len};",
+    "NODISCARD %s %s_clone(const %s* self) {\n"
+    SPACE4 "%s res = (%s){.buf = safe_calloc(self->len, sizeof(%s)), .len = self->len, .capacity = self->len};\n",
         VecT, VecT, VecT, VecT, VecT, T));
     if (primitive) {
         VecU8_append_vec(&res, VecU8_fmt(
-            SPACE4 "memcpy(res.buf, self->buf, self->len * sizeof(%s));", T));
+            SPACE4 "memcpy(res.buf, self->buf, self->len * sizeof(%s));\n", T));
     } else {
         VecU8_append_vec(&res, VecU8_fmt(
             SPACE4 "for (size_t i = 0; i < self->len; i++)\n"
             SPACE4 SPACE4 "res.buf[i] = %s_clone(&self->buf[i]);\n", T));
     }
-    VecU8_append_span(&res, cstr("}\n\n"));
+    VecU8_append_span(&res, cstr(SPACE4 "return res;\n}\n\n"));
 
     VecU8_append_vec(&res, VecU8_fmt(
     "void %s_append_vec(%s* self, %s b) {\n"
@@ -117,7 +117,7 @@ NODISCARD VecU8 generate_VecT_trivmove_extended_methods(SpanU8 T, bool primitive
 
     VecU8_append_vec(&res, VecU8_fmt(
     "NODISCARD %s %s_swap_with_empty(%s* cell) {\n"
-    SPACE4 "%s res = *cell;\n"
+    SPACE4 "%s val = *cell;\n"
     SPACE4 "*cell = (%s){NULL, 0, 0};\n"
     SPACE4 "return val;\n"
     "}\n\n", VecT, VecT, VecT, VecT, VecT));
@@ -162,7 +162,8 @@ NODISCARD VecU8 generate_VecT_equal_method(SpanU8 T, bool integer) {
         SPACE4 SPACE4 SPACE4 "return false;\n"
         SPACE4 "}\n"
         SPACE4 "return true;\n"
-        "}\n"));
+        "}\n\n"
+    ));
 
     VecU8_drop(g_VecT);
     return res;
@@ -198,7 +199,7 @@ void codegen_append_some_span_struct(VecU8* res, SpanU8 T, SpanU8 SpanT, SpanU8
         "typedef struct {\n"
         SPACE4 "%s%s* data;\n"
         SPACE4 "size_t len;\n"
-        "} %s\n\n", mod, T, SpanT));
+        "} %s;\n\n", mod, T, SpanT));
 }
 
 /* helper function. (SpanT, mod) is either (SpanT "const ") or (MutSpanT, "") */
@@ -215,8 +216,8 @@ void codegen_append_some_span_at_method(VecU8* res, SpanU8 T, SpanU8 SpanT, Span
 void codegen_append_some_span_span_method(VecU8* res, SpanU8 SpanT) {
     VecU8_append_vec(res, VecU8_fmt(
     "%s %s_span(%s self, size_t start, size_t len){\n"
-    "assert(start < SIZE_MAX - len && start + len <= self.len);\n"
-    "return (%s){.data = self.data + start, .len = len};\n"
+    SPACE4 "assert(start < SIZE_MAX - len && start + len <= self.len);\n"
+    SPACE4 "return (%s){.data = self.data + start, .len = len};\n"
     "}\n\n", SpanT, SpanT, SpanT, SpanT));
 }
 
@@ -225,7 +226,7 @@ void codegen_append_some_span_span_method(VecU8* res, SpanU8 SpanT) {
  * add_equal option generates equal method.  add_extended option generated extended methods
  * add_sort option generates T_qcompare and MutSpanT_sort methods */
 NODISCARD VecU8 generate_SpanT_struct_and_methods(
-    SpanU8 T, bool add_mutable, bool add_equal, bool add_extended, bool add_sort
+    SpanU8 T, bool integer, bool add_mutable, bool add_equal, bool add_extended, bool add_sort
     ) {
     VecU8 g_SpanT = VecU8_fmt("Span%s", T);
     VecU8 g_MutSpanT = VecU8_fmt("MutSpan%s", T);
@@ -261,10 +262,15 @@ NODISCARD VecU8 generate_SpanT_struct_and_methods(
         VecU8_append_vec(&res, VecU8_fmt(
             "int %s_qcompare(const void* a, const void* b) {\n"
             SPACE4 "const %s* A = a;\n"
-            SPACE4 "const %s* B = b;\n"
-            SPACE4 "return (int)%s_less_%s(B, A) - (int)%s_less_%s(A, B);\n"
-            "}\n\n", T, T, T, T, T, T, T));
+            SPACE4 "const %s* B = b;\n", T, T, T));
+        if (integer) {
+            VecU8_append_span(&res, cstr(SPACE4 "return (int)(B < A) - (int)(A < B);\n"));
+        } else {
+            VecU8_append_vec(&res, VecU8_fmt(
+                SPACE4 "return (int)%s_less_%s(B, A) - (int)%s_less_%s(A, B);\n", T, T, T, T));
+        }
         VecU8_append_vec(&res, VecU8_fmt(
+            "}\n\n"
             "void %s_sort(%s self) {\n"
             SPACE4 "qsort(self.data, self.len, sizeof(%s), %s_qcompare);\n"
             "}\n\n", MutSpanT, MutSpanT, T, T));
@@ -322,7 +328,7 @@ NODISCARD VecU8 generate_SpanT_VecT_trivmove_collab(SpanU8 T, bool primitive, bo
     SPACE4 "}\n", VecT, VecT, SpanT, T));
     if (primitive) {
         VecU8_append_vec(&res, VecU8_fmt(
-        SPACE4 "memcpy(self->buf + i, b.data, b.len * sizeof(%s));\n", T));
+        SPACE4 "memcpy(self->buf + self->len, b.data, b.len * sizeof(%s));\n", T));
     } else {
         VecU8_append_vec(&res, VecU8_fmt(
         SPACE4 "for (size_t i = 0; i < b.len; i++)\n"
@@ -340,7 +346,7 @@ NODISCARD VecU8 generate_SpanT_VecT_trivmove_collab(SpanU8 T, bool primitive, bo
             "}\n\n", SpanT, VecT, VecT, SpanT));
         if (add_mutable) {
             VecU8_append_vec(&res, VecU8_fmt(
-                "%s %s_span(%s* vec, size_t start, size_t len) {\n"
+                "%s %s_mspan(%s* vec, size_t start, size_t len) {\n"
                 SPACE4 "assert(start < SIZE_MAX - len && start + len <= vec->len);\n"
                 SPACE4 "return (%s){.data = vec->buf + start, .len = len};\n"
                 "}\n\n", MutSpanT, VecT, VecT, MutSpanT));
@@ -353,7 +359,7 @@ NODISCARD VecU8 generate_SpanT_VecT_trivmove_collab(SpanU8 T, bool primitive, bo
     return res;
 }
 
-NODISCARD VecU8 generate_OptionT_struct_and_methods(SpanU8 T) {
+NODISCARD VecU8 generate_OptionT_struct_and_methods(SpanU8 T, bool primitive) {
     VecU8 g_OptionT = VecU8_fmt("Option%s", T);
     SpanU8 OptionT = VecU8_to_SpanU8(&g_OptionT);
 
@@ -386,6 +392,19 @@ NODISCARD VecU8 generate_OptionT_struct_and_methods(SpanU8 T) {
     SPACE4 SPACE4 "abortf(\"Expected something in %s got None\\n\");\n"
     SPACE4 "return self.some;\n"
     "}\n\n", T, OptionT, OptionT, OptionT));
+    if (!primitive) {
+        VecU8_append_vec(&res, VecU8_fmt(
+            "void %s_drop(%s self) {\n"
+            SPACE4 "if (self.variant == Option_None)\n"
+            SPACE4 SPACE4 "%s_drop(self.some);\n"
+            "}\n\n", OptionT, OptionT, T));
+        VecU8_append_vec(&res, VecU8_fmt(
+            "NODISCARD %s %s_clone(const %s* self) {\n"
+            SPACE4 "if (self->variant == Option_None)\n"
+            SPACE4 SPACE4 "return (%s) { .variant = Option_None };\n"
+            SPACE4 "return (%s){ .variant = Option_Some, .some = %s_clone(&self->some) };\n"
+            "}\n\n", OptionT, OptionT, OptionT, OptionT, OptionT, T));
+    }
 
     VecU8_drop(g_OptionT);
     return res;
@@ -414,7 +433,7 @@ typedef struct {
 
 NODISCARD VecU8 generate_util_templates_instantiation(SpanU8 T, util_templates_instantiation_options op) {
     VecU8 res = VecU8_new();
-    assert(!op.t_primitive || op.t_integer);
+    assert(op.t_primitive || !op.t_integer);
     if (op.vec) {
         VecU8_append_vec(&res, generate_VecT_struct_and_base_methods(T, op.t_primitive));
     }
@@ -431,19 +450,22 @@ NODISCARD VecU8 generate_util_templates_instantiation(SpanU8 T, util_templates_i
         VecU8_append_vec(&res, generate_VecT_new_of_size_method(T));
     }
     if (op.span) {
-        VecU8_append_vec(&res, generate_SpanT_struct_and_methods(T, op.mut_span, false, op.span_extended, op.span_sort));
+        VecU8_append_vec(&res, generate_SpanT_struct_and_methods(T, op.t_integer, op.mut_span, false, op.span_extended, op.span_sort));
     }
     if (op.collab_vec_span) {
         assert(op.vec && op.span);
         VecU8_append_vec(&res, generate_SpanT_VecT_trivmove_collab(T, op.t_primitive, op.mut_span, op.collab_vec_span_extended));
     }
     if (op.option) {
-        VecU8_append_vec(&res, generate_OptionT_struct_and_methods(T));
+        VecU8_append_vec(&res, generate_OptionT_struct_and_methods(T, op.t_primitive));
     }
     return res;
 }
 
-void generate_lynda_header(SpanU8 name_pref, SpanU8 T, util_templates_instantiation_options op) {
+/* You want bonus_ns to be cstr(""). But if it isn't, it should end with / */
+void generate_eve_header(SpanU8 layer, SpanU8 bonus_ns, SpanU8 T, util_templates_instantiation_options op) {
+    if (op.t_integer)
+        op.t_primitive = true;
     if (op.vec_extended)
         op.vec = true;
     if (op.vec_equal)
@@ -461,11 +483,16 @@ void generate_lynda_header(SpanU8 name_pref, SpanU8 T, util_templates_instantiat
         op.vec = true;
     }
     assert(op.vec || op.span || op.option);
-    VecU8 text = generate_util_templates_instantiation(T, op);
-    VecU8 filename = VecU8_fmt("lynda/%s/%s%s%s%s%s""%s%s.h", name_pref,
+    VecU8 text = vcstr("/*Automatically generated file. Do not edit it */\n\n");
+    VecU8_append_vec(&text, generate_util_templates_instantiation(T, op));
+    VecU8 filename = VecU8_fmt("%s/eve/%s""%s%s%s%s%s""%s%s.h", layer, bonus_ns,
         cstr(op.vec ? "Vec" : ""), cstr(op.vec && op.span ? "And" : ""), cstr(op.span ? "Span" : ""),
         cstr(op.span && op.option ? "And" : ""), cstr(op.option ? "Option" : ""),
         cstr((int)op.vec + (int)op.span + (int)op.option > 1 ? "_" : ""), T);
+    VecU8_append(&filename, 0);
+    write_whole_file_or_abort((const char*)filename.buf, VecU8_to_SpanU8(&text));
+    VecU8_drop(filename);
+    VecU8_drop(text);
 }
 
 #endif
diff --git a/src/l1/core/VecU8_as_str.h b/src/l1/core/VecU8_as_str.h
index 46927b7..e21dab0 100644
--- a/src/l1/core/VecU8_as_str.h
+++ b/src/l1/core/VecU8_as_str.h
@@ -6,7 +6,7 @@
 #ifdef PROTOTYPE1_L1_CODEGEN_BOOTSTRAP_USE_CHICKEN_VECU8
 #include "chicken_VecU8.h"
 #else
-#include "../../../gen/l1/VecAndSpan_int_primitives.h"
+#include "../../../gen/l1/VecAndSpanAndOption_int_primitives.h"
 #endif
 
 VecU8 VecU8_from_cstr(const char* dc) {
diff --git a/src/l1/core/int_primitives.h b/src/l1/core/int_primitives.h
index f475bbb..604f700 100644
--- a/src/l1/core/int_primitives.h
+++ b/src/l1/core/int_primitives.h
@@ -3,8 +3,6 @@
 
 #include <stdint.h>
 
-// *Crosses-fingers* Please optimize this all out, please optimize this all out
-
 typedef uint8_t U8;
 typedef uint16_t U16;
 typedef uint32_t U32;
@@ -14,15 +12,6 @@ typedef int16_t S16;
 typedef int32_t S32;
 typedef int64_t S64;
 
-#define U8_less_U8(ap, bp) (*(ap) < *(bp))
-#define U16_less_U16(ap, bp) (*(ap) < *(bp))
-#define U32_less_U32(ap, bp) (*(ap) < *(bp))
-#define U64_less_U64(ap, bp) (*(ap) < *(bp))
-#define S8_less_S8(ap, bp) (*(ap) < *(bp))
-#define S16_less_S16(ap, bp) (*(ap) < *(bp))
-#define S32_less_S32(ap, bp) (*(ap) < *(bp))
-#define S64_less_S64(ap, bp) (*(ap) < *(bp))
-
 // todo: move these to util (l1) template instantiation too
 #define int_minmax_function_Definition(T) \
 T MIN_##T (T a, T b){ return a < b ? a : b; } \
diff --git a/src/l1/tests/t0.c b/src/l1/tests/t0.c
index 95f3e30..1ca6fb3 100644
--- a/src/l1/tests/t0.c
+++ b/src/l1/tests/t0.c
@@ -1,4 +1,4 @@
-#include "../core/VecSpan_int_primitives.h"
+#include "../../../gen/l1/VecAndSpanAndOption_int_primitives.h"
 
 int main() {
     VecU8 a = VecU8_new();
@@ -17,15 +17,14 @@ int main() {
     VecU8_append(&a, 90);
     assert(a.len == 5);
     assert(a.capacity == 8);
-    assert(*VecU8_cat(&a, 0) == 116);
+    assert(*VecU8_at(&a, 0) == 116);
     assert(*VecU8_at(&a, 1) == 18);
-    assert(*VecU8_cat(&a, 2) == 180);
+    assert(*VecU8_at(&a, 2) == 180);
     assert(*VecU8_at(&a, 3) == 9);
-    assert(*VecU8_cat(&a, 4) == 90);
+    assert(*VecU8_at(&a, 4) == 90);
     VecU8_drop(a);
 
-    U32 five = 5;
-    VecU32 b = VecU32_new_filled(3, &five);
+    VecU32 b = VecU32_new_filled(3, 5);
     assert(b.len == 3);
     assert(b.capacity == 3);
     VecU32_append(&b, 41);
@@ -48,25 +47,25 @@ int main() {
         printf("%u  %u\n", *VecU32_at(&b, i), *VecU32_at(&c, i));
     }
 
-    *VecU32_at(&b, 3) = 17;
+    *VecU32_mat(&b, 3) = 17;
     assert(!VecU32_equal_VecU32(&b, &c));
-    *VecU32_at(&c, 3) = 17;
+    *VecU32_mat(&c, 3) = 17;
     assert(VecU32_equal_VecU32(&b, &c));
 
-    SpanU32 s0 = VecU32_span(&c, 4, 0);
-    SpanU32 s1 = VecU32_span(&c, 3, 1);
-    SpanU32 s2 = VecU32_span(&c, 2, 2);
-    SpanU32 s3 = VecU32_span(&c, 1, 3);
-    SpanU32 s4 = VecU32_span(&c, 0, 4);
-    assert(*SpanU32_cat(s4, 3) == 17);
+    MutSpanU32 s0 = VecU32_mspan(&c, 4, 0);
+    MutSpanU32 s1 = VecU32_mspan(&c, 3, 1);
+    MutSpanU32 s2 = VecU32_mspan(&c, 2, 2);
+    MutSpanU32 s3 = VecU32_mspan(&c, 1, 3);
+    MutSpanU32 s4 = VecU32_mspan(&c, 0, 4);
+    assert(*MutSpanU32_at(s4, 3) == 17);
     for (size_t i = 0; i < 3; i++) {
-        *VecU32_at(&c, i) = i;
+        *VecU32_mat(&c, i) = i;
     }
-    *SpanU32_at(s3, 2) = 3;
-    assert(*SpanU32_at(s1, 0) == 3);
-    assert(*SpanU32_at(s2, 0) == 2);
-    assert(*SpanU32_at(s3, 0) == 1);
-    assert(*SpanU32_at(s4, 0) == 0);
+    *MutSpanU32_at(s3, 2) = 3;
+    assert(*MutSpanU32_at(s1, 0) == 3);
+    assert(*MutSpanU32_at(s2, 0) == 2);
+    assert(*MutSpanU32_at(s3, 0) == 1);
+    assert(*MutSpanU32_at(s4, 0) == 0);
     VecU32 d = VecU32_clone(&c);
     VecU32 e = VecU32_clone(&c);
     VecU32_append(&c, 50);
@@ -75,9 +74,9 @@ int main() {
     assert(d.capacity == 4);
     assert(c.len == 5);
     for (int i = 0; i < 4; i++) {
-        VecU32_pop_and_drop(&d);
+        VecU32_pop(&d);
     }
-    assert(*VecU32_cat(&e, 4) == 500);
+    assert(*VecU32_at(&e, 4) == 500);
 
     VecU32_drop(e);
     VecU32_drop(d);
diff --git a/src/l1/tests/t1.c b/src/l1/tests/t1.c
index 3ffe897..51978a5 100644
--- a/src/l1/tests/t1.c
+++ b/src/l1/tests/t1.c
@@ -1,15 +1,16 @@
-#include "../core/VecSpan_Vec_int_primitives.h"
+#include "../../../gen/l1/VecAndSpanAndOption_int_primitives.h"
+#include "../../../gen/l1/VecAndSpan_Vec_int_primitives.h"
 
 int main() {
     VecU64 v = VecU64_new();
     for (int i = 0; i < 3; i++) {
         VecU64_append(&v, i);
-        *VecU64_at(&v, i) = *VecU64_cat(&v, i) + 10;
+        *VecU64_mat(&v, i) = *VecU64_at(&v, i) + 10;
     }
     VecVecU64 a = VecVecU64_new_filled(2, &v);
     VecU64_drop(v);
     assert(VecU64_equal_VecU64(VecVecU64_at(&a, 0), VecVecU64_at(&a, 1)));
-    VecU64_pop_and_drop(VecVecU64_at(&a, 1));
+    VecU64_pop(VecVecU64_mat(&a, 1));
     assert(!VecU64_equal_VecU64(VecVecU64_at(&a, 0), VecVecU64_at(&a, 1)));
     VecVecU64 b = VecVecU64_new();
     VecVecU64_append(&b, VecU64_new());
@@ -17,11 +18,11 @@ int main() {
     VecVecU64_append(&b, VecU64_new());
     assert(!VecVecU64_equal_VecVecU64(&a, &b));
     for (int i = 0; i < 3; i++) {
-        VecU64_append(VecVecU64_at(&b, 0), 10 + i);
+        VecU64_append(VecVecU64_mat(&b, 0), 10 + i);
     }
     assert(!VecVecU64_equal_VecVecU64(&a, &b));
     for (int i = 0; i < 2; i++) {
-        VecU64_append(VecVecU64_at(&b, 1), 10 + i);
+        VecU64_append(VecVecU64_mat(&b, 1), 10 + i);
     }
     assert(VecVecU64_equal_VecVecU64(&a, &b));
     VecVecU64 c = VecVecU64_clone(&a);