diff --git a/lib/std/core/builtin.c3 b/lib/std/core/builtin.c3
index cfcdf4c25..f504360d1 100644
--- a/lib/std/core/builtin.c3
+++ b/lib/std/core/builtin.c3
@@ -3,6 +3,7 @@
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::builtin;
 import libc;
+import std::hash;
 
 fault IteratorResult
 {
@@ -157,4 +158,5 @@ macro uint ichar.hash(ichar c) = c;
 macro uint long.hash(long i) = (uint)((i >> 32) ^ i);
 macro uint ulong.hash(ulong i) = (uint)((i >> 32) ^ i);
 macro uint bool.hash(bool b) = (uint)b;
-macro uint typeid.hash(typeid t) = (uint)(((uptr)t >> 32) ^ (uptr)t);
\ No newline at end of file
+macro uint typeid.hash(typeid t) = (uint)(((uptr)t >> 32) ^ (uptr)t);
+macro uint char[].hash(char[] c) = (uint)fnv32a::encode(c);
\ No newline at end of file
diff --git a/lib/std/hash/fnv32a.c3 b/lib/std/hash/fnv32a.c3
new file mode 100644
index 000000000..7582bd176
--- /dev/null
+++ b/lib/std/hash/fnv32a.c3
@@ -0,0 +1,41 @@
+// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::hash::fnv32a;
+
+define Fnv32a = distinct uint;
+
+private const FNV32A_START = 0x811c9dc5;
+private const FNV32A_MUL = 0x01000193;
+
+private macro void @update(uint &h, char x) => h = (h * FNV32A_MUL) ^ x;
+
+fn void Fnv32a.init(Fnv32a* this)
+{
+    *this = FNV32A_START;
+}
+
+fn void Fnv32a.update(Fnv32a* this, char[] data)
+{
+	uint h = (uint)*this;
+	foreach (char x : data)
+    {
+        @update(h, x);
+    }
+    *this = (Fnv32a)h;
+}
+
+macro void Fnv32a.update_char(Fnv32a* this, char c)
+{
+	@update(*this, x);
+}
+
+fn uint encode(char[] data)
+{
+	uint h = FNV32A_START;
+	foreach (char x : data)
+    {
+		@update(h, x);
+    }
+    return h;
+}
\ No newline at end of file
diff --git a/lib/std/map.c3 b/lib/std/map.c3
index 94b9fd869..3d65ea58d 100644
--- a/lib/std/map.c3
+++ b/lib/std/map.c3
@@ -22,13 +22,13 @@ struct HashMap
 }
 
 /**
- * @require capacity > 0
- * @require load_factor > 0.0 && load_factor < 1.0
- * @require map.table.len == 0
- * @require capacity < MAXIMUM_CAPACITY
- * @require allocator != null
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !map.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ * @require allocator != null "The allocator must be non-null"
  **/
-fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = mem::current_allocator())
+fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = mem::temp_allocator())
 {
 	capacity = math::next_power_of_2(capacity);
 	map.allocator = allocator;
@@ -37,7 +37,7 @@ fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, flo
 	map.table = array::make(Entry*, capacity, allocator);
 }
 
-fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* allocator = mem::current_allocator())
+fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* allocator = mem::temp_allocator())
 {
 	map.init(other_map.table.len, other_map.load_factor, allocator);
 	map.put_all_for_create(other_map);
@@ -59,7 +59,7 @@ fn Value*! HashMap.get_ref(HashMap* map, Key key)
 	return SearchResult.MISSING!;
 }
 
-fn Value! HashMap.get(HashMap* map, Key key)
+fn Value! HashMap.get(HashMap* map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }
@@ -70,8 +70,13 @@ fn bool HashMap.has_key(HashMap* map, Key key)
 	return try(map.get_ref(key));
 }
 
-fn bool HashMap.set(HashMap* map, Key key, Value value)
+fn bool HashMap.set(HashMap* map, Key key, Value value) @operator([]=)
 {
+	// If the map isn't initialized, use the defaults to initialize it.
+	if (!map.allocator)
+	{
+		map.init();
+	}
 	uint hash = rehash(key.hash());
 	uint index = index_for(hash, map.table.len);
 	for (Entry *e = map.table[index]; e != null; e = e.next)
@@ -106,20 +111,17 @@ fn void HashMap.clear(HashMap* map)
 
 fn void HashMap.destroy(HashMap* map)
 {
+	if (!map.allocator) return;
 	map.clear();
 	map.free(map.table.ptr);
 	map.table = Entry*[] {};
 }
-fn Key[] HashMap.key_tlist(HashMap* map)
-{
-	return map.key_list(mem::temp_allocator());
-}
 
-fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = null)
+fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = mem::temp_allocator())
 {
 	if (!map.count) return Key[] {};
 
-	Key[] list = array::make(Key, map.count, allocator ?: map.allocator);
+	Key[] list = array::make(Key, map.count, allocator);
 	usize index = 0;
 	foreach (Entry* entry : map.table)
 	{
@@ -132,15 +134,10 @@ fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = null)
 	return list;
 }
 
-fn Value[] HashMap.value_tlist(HashMap* map)
-{
-	return map.value_list(mem::temp_allocator());
-}
-
-fn Value[] HashMap.value_list(HashMap* map, Allocator* allocator = null)
+fn Value[] HashMap.value_list(HashMap* map, Allocator* allocator = mem::temp_allocator())
 {
 	if (!map.count) return Value[] {};
-	Value[] list = array::make(Value, map.count, allocator ?: map.allocator);
+	Value[] list = array::make(Value, map.count, allocator);
 	usize index = 0;
 	foreach (Entry* entry : map.table)
 	{
diff --git a/resources/examples/hash.c3 b/resources/examples/hash.c3
index 98e607573..f20f09971 100644
--- a/resources/examples/hash.c3
+++ b/resources/examples/hash.c3
@@ -1,4 +1,4 @@
-module hash;
+module std::hash;
 import libc;
 
 // Code adapted from Odin's hash.odin
diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h
index a6c73ba37..cf593d912 100644
--- a/src/compiler/compiler_internal.h
+++ b/src/compiler/compiler_internal.h
@@ -345,7 +345,6 @@ struct TypeInfo_
 	TypeInfoCompressedKind subtype : 4;
 	Type *type;
 	SourceSpan span;
-
 	union
 	{
 		struct
@@ -773,6 +772,13 @@ typedef struct
 	Range range;
 } ExprSubscript;
 
+typedef struct
+{
+	ExprId expr;
+	DeclId method;
+	ExprId index;
+} ExprSubscriptAssign;
+
 typedef struct
 {
 	ExprId left;
@@ -1105,6 +1111,7 @@ struct Expr_
 		ExprBuiltinAccess builtin_access_expr;
 		ExprCatchUnwrap catch_unwrap_expr;          // 24
 		ExprSubscript subscript_expr;               // 12
+		ExprSubscriptAssign subscript_assign_expr;
 		ExprAccess access_expr;                     // 16
 		ExprDesignator designator_expr;             // 16
 		ExprIdentifier identifier_expr;             // 24
@@ -1837,6 +1844,7 @@ extern const char *kw_return;
 extern const char *kw_type;
 extern const char *kw_FILE;
 extern const char *kw_FUNC;
+extern const char *kw_FUNCPTR;
 extern const char *kw_LINE;
 extern const char *kw_LINEREAL;
 extern const char *kw_incr;
diff --git a/src/compiler/copying.c b/src/compiler/copying.c
index eed85682c..f5b3ab2ba 100644
--- a/src/compiler/copying.c
+++ b/src/compiler/copying.c
@@ -356,6 +356,8 @@ Expr *copy_expr(CopyStruct *c, Expr *source_expr)
 			MACRO_COPY_EXPRID(expr->slice_assign_expr.left);
 			MACRO_COPY_EXPRID(expr->slice_assign_expr.right);
 			return expr;
+		case EXPR_SUBSCRIPT_ASSIGN:
+			UNREACHABLE
 		case EXPR_SLICE:
 		case EXPR_SUBSCRIPT:
 		case EXPR_SUBSCRIPT_ADDR:
diff --git a/src/compiler/enums.h b/src/compiler/enums.h
index 48b1baec7..4a834e6d7 100644
--- a/src/compiler/enums.h
+++ b/src/compiler/enums.h
@@ -240,6 +240,7 @@ typedef enum
 	EXPR_SLICE_COPY,
 	EXPR_SUBSCRIPT,
 	EXPR_SUBSCRIPT_ADDR,
+	EXPR_SUBSCRIPT_ASSIGN,
 	EXPR_POINTER_OFFSET,
 	EXPR_STRINGIFY,
 	EXPR_ARGV_TO_SUBARRAY,
diff --git a/src/compiler/expr.c b/src/compiler/expr.c
index 9ce20a1ef..702b4d8ce 100644
--- a/src/compiler/expr.c
+++ b/src/compiler/expr.c
@@ -132,6 +132,7 @@ bool expr_may_addr(Expr *expr)
 		case EXPR_VASPLAT:
 		case EXPR_OPERATOR_CHARS:
 		case EXPR_CT_CHECKS:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			return false;
 	}
 	UNREACHABLE
@@ -319,6 +320,7 @@ bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind)
 		case EXPR_ARGV_TO_SUBARRAY:
 		case EXPR_CT_ARG:
 		case EXPR_ASM:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			UNREACHABLE
 		case EXPR_NOP:
 			return true;
@@ -703,6 +705,7 @@ bool expr_is_pure(Expr *expr)
 		case EXPR_TRY_UNWRAP:
 		case EXPR_TRY_UNWRAP_CHAIN:
 		case EXPR_FORCE_UNWRAP:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			return false;
 		case EXPR_CAST:
 			return exprid_is_pure(expr->cast_expr.expr);
diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c
index 670410b59..93ba77231 100644
--- a/src/compiler/llvm_codegen_expr.c
+++ b/src/compiler/llvm_codegen_expr.c
@@ -5688,6 +5688,7 @@ void llvm_emit_expr(GenContext *c, BEValue *value, Expr *expr)
 			return;
 		case EXPR_TYPEID:
 		case EXPR_GROUP:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			// These are folded in the semantic analysis step.
 			UNREACHABLE
 		case EXPR_IDENTIFIER:
diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c
index 314d46c38..1ed117c5e 100644
--- a/src/compiler/sema_casts.c
+++ b/src/compiler/sema_casts.c
@@ -849,6 +849,7 @@ Expr *recursive_may_narrow_float(Expr *expr, Type *type)
 		case EXPR_VASPLAT:
 		case EXPR_OPERATOR_CHARS:
 		case EXPR_CT_CHECKS:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			UNREACHABLE
 		case EXPR_BUILTIN_ACCESS:
 
@@ -953,6 +954,7 @@ Expr *recursive_may_narrow_int(Expr *expr, Type *type)
 		case EXPR_SLICE:
 		case EXPR_SUBSCRIPT:
 		case EXPR_RETVAL:
+		case EXPR_SUBSCRIPT_ASSIGN:
 		case EXPR_TYPEID_INFO:
 			if (type_size(expr->type) > type_size(type)) return expr;
 			return NULL;
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index e3a3b2196..a90981abe 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -1247,13 +1247,7 @@ static inline bool sema_analyse_operator_element_set(Decl *method)
 {
 	TypeInfo *rtype;
 	Decl **params;
-	if (!sema_analyse_operator_common(method, &rtype, &params, 3)) return false;
-	if (rtype->type->canonical != type_void)
-	{
-		SEMA_ERROR(rtype, "The return type should be 'void'.");
-		return false;
-	}
-	return true;
+	return sema_analyse_operator_common(method, &rtype, &params, 3);
 }
 
 static inline bool sema_analyse_operator_len(Decl *method)
diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c
index 9b8316611..29d8a7891 100644
--- a/src/compiler/sema_expr.c
+++ b/src/compiler/sema_expr.c
@@ -7,6 +7,13 @@
 
 const char *ct_eval_error = "EVAL_ERROR";
 
+typedef enum
+{
+	SUBSCRIPT_EVAL_VALUE,
+	SUBSCRIPT_EVAL_REF,
+	SUBSCRIPT_EVAL_ASSIGN
+} SubscriptEval;
+
 typedef struct
 {
 	bool macro;
@@ -17,7 +24,7 @@ typedef struct
 	Signature *signature;
 } CalledDecl;
 
-static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr, bool is_addr);
+static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr, SubscriptEval eval_type);
 static inline bool sema_expr_analyse_pointer_offset(SemaContext *context, Expr *expr);
 static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr);
 static inline bool sema_expr_analyse_group(SemaContext *context, Expr *expr);
@@ -208,31 +215,68 @@ Expr *sema_expr_analyse_ct_arg_index(SemaContext *context, Expr *index_expr)
 	return context->macro_varargs[(size_t)index_val.i.low];
 }
 
-const char *sema_ct_eval_expr(SemaContext *c, const char *expr_type, Expr *inner, TokenType *type, Path **path_ref, bool report_missing)
+Expr *sema_ct_eval_expr(SemaContext *c, bool is_type_eval, Expr *inner, bool report_missing)
 {
+	Path *path = NULL;
 	if (!sema_analyse_expr(c, inner)) return false;
 	if (!expr_is_const_string(inner))
 	{
-		SEMA_ERROR(inner, "'%s' expects a constant string as the argument.", expr_type);
-		return ct_eval_error;
-	}
-	const char *interned_version = NULL;
-	if (!splitpathref(inner->const_expr.string.chars, inner->const_expr.string.len, path_ref, &interned_version, type))
-	{
-		SEMA_ERROR(inner, "A valid name was expected here.");
-		return ct_eval_error;
-	}
-	if (*path_ref) (*path_ref)->span = inner->span;
-	if (*type == TOKEN_INVALID_TOKEN)
-	{
-		if (report_missing)
-		{
-			SEMA_ERROR(inner, "'%s' could not be found, did you spell it right?", interned_version);
-			return ct_eval_error;
-		}
+		SEMA_ERROR(inner, "'%s' expects a constant string as the argument.", is_type_eval ? "$evaltype" : "$eval");
 		return NULL;
 	}
-	return interned_version;
+	const char *interned_version = NULL;
+	TokenType token = sema_splitpathref(inner->const_expr.string.chars, inner->const_expr.string.len, &path, &interned_version);
+	switch (token)
+	{
+		case TOKEN_CONST_IDENT:
+			inner->identifier_expr.is_const = true;
+			break;
+		case TOKEN_IDENT:
+			if (!interned_version)
+			{
+				if (report_missing)
+				{
+					SEMA_ERROR(inner, "'%.*s' could not be found, did you spell it right?", (int)inner->const_expr.string.len, inner->const_expr.string.chars);
+				}
+				return NULL;
+			}
+			inner->identifier_expr.is_const = false;
+			break;
+		case TYPE_TOKENS:
+		{
+			TypeInfo *info = type_info_new_base(type_from_token(token), inner->span);
+			inner->expr_kind = EXPR_TYPEINFO;
+			inner->resolve_status = RESOLVE_NOT_DONE;
+			inner->type_expr = info;
+			return inner;
+		}
+		case TOKEN_TYPE_IDENT:
+		{
+			TypeInfo *info = type_info_new(TYPE_INFO_IDENTIFIER, inner->span);
+			info->unresolved.name = interned_version;
+			info->unresolved.path = path;
+			info->resolve_status = RESOLVE_NOT_DONE;
+			inner->expr_kind = EXPR_TYPEINFO;
+			inner->resolve_status = RESOLVE_NOT_DONE;
+			inner->type_expr = info;
+			return inner;
+		}
+		default:
+			if (is_type_eval)
+			{
+				SEMA_ERROR(inner, "Only valid types may be resolved with $evaltype.");
+			}
+			else
+			{
+				SEMA_ERROR(inner, "Only plain function, variable and constant names may be resolved with $eval.");
+			}
+			return NULL;
+	}
+	inner->expr_kind = EXPR_IDENTIFIER;
+	inner->resolve_status = RESOLVE_NOT_DONE;
+	inner->identifier_expr.ident = interned_version;
+	inner->identifier_expr.path = path;
+	return inner;
 }
 
 static Expr *expr_access_inline_member(Expr *parent, Decl *parent_decl)
@@ -308,6 +352,7 @@ static bool sema_binary_is_expr_lvalue(Expr *top_expr, Expr *expr)
 {
 	switch (expr->expr_kind)
 	{
+		case EXPR_SUBSCRIPT_ASSIGN:
 		case EXPR_CT_IDENT:
 			return true;
 		case EXPR_IDENTIFIER:
@@ -433,6 +478,7 @@ ERR:
 bool sema_expr_check_assign(SemaContext *c, Expr *expr)
 {
 	if (!sema_binary_is_expr_lvalue(expr, expr)) return false;
+	if (expr->expr_kind == EXPR_SUBSCRIPT_ASSIGN) return true;
 	if (expr->expr_kind == EXPR_BITACCESS || expr->expr_kind == EXPR_ACCESS) expr = expr->access_expr.parent;
 	if (expr->expr_kind == EXPR_IDENTIFIER)
 	{
@@ -2177,7 +2223,56 @@ static bool sema_subscript_rewrite_index_const_list(Expr *const_list, Expr *inde
 	return expr_rewrite_to_const_initializer_index(const_list->type, const_list->const_expr.initializer, result, idx);
 }
 
-static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr, bool is_addr)
+/**
+ * Find index type or overload for subscript.
+ */
+static Expr *sema_expr_find_index_type_or_overload_for_subscript(SemaContext *context, Expr *current_expr, SubscriptEval eval_type, Type **index_type_ptr, Decl **overload_ptr)
+{
+	Decl *overload = NULL;
+	switch (eval_type)
+	{
+		case SUBSCRIPT_EVAL_REF:
+			overload = sema_find_operator(context, current_expr, OVERLOAD_ELEMENT_REF);
+			break;
+		case SUBSCRIPT_EVAL_VALUE:
+			overload = sema_find_operator(context, current_expr, OVERLOAD_ELEMENT_AT);
+			break;
+		case SUBSCRIPT_EVAL_ASSIGN:
+			overload = sema_find_operator(context, current_expr, OVERLOAD_ELEMENT_SET);
+			if (overload)
+			{
+				*overload_ptr = overload;
+				assert(vec_size(overload->func_decl.signature.params) == 3);
+				*index_type_ptr = overload->func_decl.signature.params[2]->type;
+				return current_expr;
+			}
+			break;
+	}
+	// Overload found for [] and &[]
+	if (overload)
+	{
+		*overload_ptr = overload;
+		assert(overload->func_decl.signature.rtype);
+		*index_type_ptr = type_infoptr(overload->func_decl.signature.rtype)->type;
+		return current_expr;
+	}
+	// Otherwise, see if we have an indexed type.
+	Type *inner_type = type_get_indexed_type(current_expr->type);
+	if (inner_type)
+	{
+		*index_type_ptr  = inner_type;
+		*overload_ptr = NULL;
+		return current_expr;
+	}
+	if (type_is_substruct(current_expr->type))
+	{
+		Expr *embedded_struct = expr_access_inline_member(current_expr, current_expr->type->decl);
+		return sema_expr_find_index_type_or_overload_for_subscript(context, embedded_struct, eval_type, index_type_ptr, overload_ptr);
+	}
+	return NULL;
+}
+
+static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr, SubscriptEval eval_type)
 {
 	assert(expr->expr_kind == EXPR_SUBSCRIPT || expr->expr_kind == EXPR_SUBSCRIPT_ADDR);
 
@@ -2196,7 +2291,6 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 	Type *underlying_type = type_flatten(subscripted->type);
 
 	Type *current_type = underlying_type;
-	Expr *current_expr = subscripted;
 
 	int64_t index_value = -1;
 	bool start_from_end = expr->subscript_expr.range.start_from_end;
@@ -2208,7 +2302,7 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 			SEMA_ERROR(index, "The index may not be negative.");
 			return false;
 		}
-		int64_t size = current_type == type_untypedlist ? vec_size(current_expr->const_expr.untyped_list) : current_type->array.len;
+		int64_t size = current_type == type_untypedlist ? vec_size(subscripted->const_expr.untyped_list) : current_type->array.len;
 		assert(size >= 0 && "Unexpected overflow");
 		if (!int_fits(index->const_expr.ixx, TYPE_I64) || size == 0)
 		{
@@ -2246,13 +2340,14 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 	// 4. If we are indexing into a complist
 	if (underlying_type == type_untypedlist)
 	{
-		if (is_addr)
+		if (eval_type == SUBSCRIPT_EVAL_REF)
 		{
 			SEMA_ERROR(subscripted, "You need to use && to take the address of a temporary.");
 			return false;
 		}
 		// 4a. This may either be an initializer list or a CT value
-		while (current_expr->expr_kind == EXPR_CT_IDENT) current_expr = current_expr->ct_ident_expr.decl->var.init_expr;
+		Expr *current_expr = subscripted;
+		while (subscripted->expr_kind == EXPR_CT_IDENT) current_expr = current_expr->ct_ident_expr.decl->var.init_expr;
 
 		// 4b. Now we need to check that we actually have a valid type.
 		if (index_value < 0)
@@ -2260,39 +2355,50 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 			SEMA_ERROR(index, "To subscript an untyped list a compile time integer index is needed.");
 			return false;
 		}
-		expr_replace(expr, subscripted->const_expr.untyped_list[index_value]);
+		if (eval_type == SUBSCRIPT_EVAL_ASSIGN) TODO;
+		expr_replace(expr, current_expr->const_expr.untyped_list[index_value]);
 		return true;
 	}
 
-	if (!sema_cast_rvalue(context, current_expr)) return false;
+	if (!sema_cast_rvalue(context, subscripted)) return false;
 
-	Type *inner_type = sema_subscript_find_indexable_type_recursively(&current_type, &current_expr);
-	if (!inner_type)
+	Decl *overload = NULL;
+	Type *index_type = NULL;
+	Expr *current_expr = sema_expr_find_index_type_or_overload_for_subscript(context, subscripted, eval_type, &index_type, &overload);
+	if (!index_type)
 	{
-		Decl *decl = NULL;
-		if (is_addr) decl = sema_find_operator(context, current_expr, OVERLOAD_ELEMENT_REF);
-		if (!decl)
+		if (!overload && eval_type == SUBSCRIPT_EVAL_REF)
 		{
-			decl = sema_find_operator(context, current_expr, OVERLOAD_ELEMENT_AT);
-			if (decl && is_addr)
+			// Maybe there is a [] overload?
+			if (sema_expr_find_index_type_or_overload_for_subscript(context,
+			                                                        subscripted,
+			                                                        SUBSCRIPT_EVAL_VALUE,
+			                                                        &index_type,
+			                                                        &overload))
 			{
-				SEMA_ERROR(expr, "A function or macro with '@operator([])' is not defined for %s, so you need && to take the address of the temporary.",
+				SEMA_ERROR(expr,
+				           "A function or macro with '@operator(&[])' is not defined for %s, so you need && to take the address of the temporary.",
 				           type_quoted_error_string(current_expr->type));
 				return false;
 			}
 		}
-		if (decl)
-		{
-			Expr **args = NULL;
-			vec_add(args, index);
-			return sema_insert_method_call(context, expr, decl, current_expr, args);
-		}
-	}
-	if (!inner_type)
-	{
 		SEMA_ERROR(subscripted, "Cannot index '%s'.", type_to_error_string(subscripted->type));
 		return false;
 	}
+	if (overload)
+	{
+		if (eval_type == SUBSCRIPT_EVAL_ASSIGN)
+		{
+			expr->expr_kind = EXPR_SUBSCRIPT_ASSIGN;
+			expr->subscript_assign_expr.expr = exprid(current_expr);
+			expr->subscript_assign_expr.index = exprid(index);
+			expr->subscript_assign_expr.method = declid(overload);
+			return true;
+		}
+		Expr **args = NULL;
+		vec_add(args, index);
+		return sema_insert_method_call(context, expr, overload, current_expr, args);
+	}
 
 	// Cast to an appropriate type for index.
 	if (!cast_to_index(index)) return false;
@@ -2306,9 +2412,9 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 		(void)start_from_end;
 	}
 
-	if (is_addr)
+	if (eval_type == SUBSCRIPT_EVAL_REF)
 	{
-		inner_type = type_get_ptr(inner_type);
+		index_type = type_get_ptr(index_type);
 	}
 	else
 	{
@@ -2318,7 +2424,7 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
 		}
 	}
 	expr->subscript_expr.expr = exprid(current_expr);
-	expr->type = type_add_optional(inner_type, failable);
+	expr->type = type_add_optional(index_type, failable);
 	return true;
 }
 
@@ -2509,30 +2615,17 @@ RETRY:
 		}
 		case EXPR_CT_EVAL:
 		{
-			Expr *inner = child->inner_expr;
 			TokenType type;
 			// Only report missing if missing var is NULL
 			Path *path = NULL;
-			const char *ident = sema_ct_eval_expr(context, "$eval", inner, &type, &path, missing == NULL);
-			if (!ident && missing)
+			Expr *result = sema_ct_eval_expr(context, false, child->inner_expr, missing == NULL);
+			if (!result)
 			{
-				*missing = true;
+				if (missing) *missing = true;
 				return NULL;
 			}
-			if (ident == ct_eval_error) return NULL;
-			switch (type)
-			{
-				case TOKEN_IDENT:
-				case TOKEN_CONST_IDENT:
-					child->expr_kind = EXPR_IDENTIFIER;
-					child->identifier_expr.ident = ident;
-					child->identifier_expr.path = path;
-					child->identifier_expr.is_const = type == TOKEN_CONST_IDENT;
-					goto RETRY;
-				default:
-					SEMA_ERROR(inner, "Only function, variable and constant names may be resolved with $eval.");
-					return NULL;
-			}
+			expr_replace(child, result);
+			goto RETRY;
 		}
 		default:
 			break;
@@ -3693,9 +3786,16 @@ static bool sema_expr_analyse_assign(SemaContext *context, Expr *expr, Expr *lef
 	{
 		return sema_expr_analyse_ct_type_identifier_assign(context, expr, left, right);
 	}
+	if (left->expr_kind == EXPR_SUBSCRIPT)
+	{
+		if (!sema_expr_analyse_subscript(context, left, SUBSCRIPT_EVAL_ASSIGN)) return false;
+	}
+	else
+	{
+		if (!sema_analyse_expr_lvalue(context, left)) return false;
+	}
 
-	if (!sema_analyse_expr_lvalue(context, left)) return false;
-
+	bool is_subscript_assign = left->expr_kind == EXPR_SUBSCRIPT_ASSIGN;
 
 	// 2. Check assignability
 	if (!sema_expr_check_assign(context, left)) return false;
@@ -3710,6 +3810,13 @@ static bool sema_expr_analyse_assign(SemaContext *context, Expr *expr, Expr *lef
 		sema_rewrap_var(context, left->identifier_expr.decl);
 		return true;
 	}
+	if (left->expr_kind == EXPR_SUBSCRIPT_ASSIGN)
+	{
+		Expr **args = NULL;
+		vec_add(args, exprptr(left->subscript_assign_expr.index));
+		vec_add(args, right);
+		return sema_insert_method_call(context, expr, declptr(left->subscript_assign_expr.method), exprptr(left->subscript_assign_expr.expr), args);
+	}
 	if (left->expr_kind == EXPR_BITACCESS)
 	{
 		if (!sema_bit_assignment_check(right, left->access_expr.ref)) return false;
@@ -5523,6 +5630,28 @@ static inline bool sema_expr_analyse_compiler_const(SemaContext *context, Expr *
 		expr_rewrite_to_string(expr, context->compilation_unit->file->name);
 		return true;
 	}
+	if (string == kw_FUNCPTR)
+	{
+
+		switch (context->call_env.kind)
+		{
+			case CALL_ENV_GLOBAL_INIT:
+			case CALL_ENV_CHECKS:
+			case CALL_ENV_INITIALIZER:
+			case CALL_ENV_FINALIZER:
+			case CALL_ENV_ATTR:
+				expr_rewrite_to_const_zero(expr, type_voidptr);
+				return true;
+			case CALL_ENV_FUNCTION:
+				expr->expr_kind = EXPR_IDENTIFIER;
+				expr->resolve_status = RESOLVE_DONE;
+				expr->identifier_expr.decl = context->call_env.current_function;
+				expr->type = expr->identifier_expr.decl->type;
+				expr_insert_addr(expr);
+				return true;
+		}
+		UNREACHABLE
+	}
 	if (string == kw_FUNC)
 	{
 		switch (context->call_env.kind)
@@ -5932,25 +6061,15 @@ RETRY:
 		case TYPE_INFO_EVALTYPE:
 		{
 			Expr *expr = type_info->unresolved_type_expr;
-			TokenType type;
-			Path *path = NULL;
-			const char *ident = sema_ct_eval_expr(context, "$eval", expr, &type, &path, false);
-			if (!ident) return NULL;
-			if (ident == ct_eval_error) return poisoned_type;
-			switch (type)
+			expr = sema_ct_eval_expr(context, "$evaltype", expr, false);
+			if (!expr) return NULL;
+			if (expr->expr_kind != EXPR_TYPEINFO)
 			{
-				case TOKEN_TYPE_IDENT:
-					type_info->unresolved.name = ident;
-					type_info->span = expr->span;
-					type_info->unresolved.path = path;
-					type_info->kind = TYPE_INFO_IDENTIFIER;
-					goto RETRY;
-				case TYPE_TOKENS:
-					return type_info->type = type_from_token(type);
-				default:
-					SEMA_ERROR(expr, "Only type names may be resolved with $evaltype.");
-					return poisoned_type;
+				SEMA_ERROR(expr, "Only type names may be resolved with $evaltype.");
+				return poisoned_type;
 			}
+			type_info = expr->type_expr;
+			goto RETRY;
 		}
 		case TYPE_INFO_SUBARRAY:
 		{
@@ -6055,28 +6174,9 @@ RETRY:
 			if (!sema_expr_analyse_builtin(context, main_var, false)) goto NOT_DEFINED;
 			break;
 		case EXPR_CT_EVAL:
-		{
-			Expr *inner = main_var->inner_expr;
-			TokenType token_type;
-			Path *path = NULL;
-			const char *ident = sema_ct_eval_expr(context, "$eval", inner, &token_type, &path, false);
-			if (ident == ct_eval_error) return false;
-			if (!ident) goto NOT_DEFINED;
-			switch (token_type)
-			{
-				case TOKEN_IDENT:
-				case TOKEN_CONST_IDENT:
-					main_var->expr_kind = EXPR_IDENTIFIER;
-					main_var->resolve_status = RESOLVE_NOT_DONE;
-					main_var->identifier_expr.ident = ident;
-					main_var->identifier_expr.path = path;
-					main_var->identifier_expr.is_const = token_type == TOKEN_CONST_IDENT;
-					goto RETRY;
-				default:
-					SEMA_ERROR(inner, "Only function, variable and constant names may be resolved with $eval.");
-					return false;
-			}
-		}
+			main_var = sema_ct_eval_expr(context, "$eval", main_var->inner_expr, false);
+			if (!main_var) goto NOT_DEFINED;
+			goto RETRY;
 		default:
 			SEMA_ERROR(main_var, "Expected an identifier here.");
 			return false;
@@ -6245,24 +6345,17 @@ static inline bool sema_expr_analyse_ct_stringify(SemaContext *context, Expr *ex
 
 static inline bool sema_expr_analyse_ct_eval(SemaContext *context, Expr *expr)
 {
-	Expr *inner = expr->inner_expr;
 	TokenType type;
 	Path *path = NULL;
-	const char *ident = sema_ct_eval_expr(context, "$eval", inner, &type, &path, true);
-	if (ident == ct_eval_error) return false;
-	switch (type)
+	Expr *result = sema_ct_eval_expr(context, "$eval", expr->inner_expr, true);
+	if (!result) return false;
+	if (result->expr_kind == EXPR_TYPEINFO)
 	{
-		case TOKEN_IDENT:
-		case TOKEN_CONST_IDENT:
-			expr->expr_kind = EXPR_IDENTIFIER;
-			expr->identifier_expr.ident = ident;
-			expr->identifier_expr.path = path;
-			expr->identifier_expr.is_const = type == TOKEN_CONST_IDENT;
-			return sema_analyse_expr_dispatch(context, expr);
-		default:
-			SEMA_ERROR(inner, "Only function, variable and constant names may be resolved with $eval.");
-			return false;
+		SEMA_ERROR(result, "Evaluation to a type requires the use of '$evaltype' rather than '$eval'.");
+		return false;
 	}
+	expr_replace(expr, result);
+	return sema_analyse_expr_dispatch(context, expr);
 }
 
 
@@ -6481,12 +6574,13 @@ static inline bool sema_analyse_expr_dispatch(SemaContext *context, Expr *expr)
 		case EXPR_CALL:
 			return sema_expr_analyse_call(context, expr);
 		case EXPR_SUBSCRIPT:
-			return sema_expr_analyse_subscript(context, expr, false);
+			return sema_expr_analyse_subscript(context, expr, SUBSCRIPT_EVAL_VALUE);
 		case EXPR_SUBSCRIPT_ADDR:
-			return sema_expr_analyse_subscript(context, expr, true);
+			return sema_expr_analyse_subscript(context, expr, SUBSCRIPT_EVAL_REF);
 		case EXPR_GROUP:
 			return sema_expr_analyse_group(context, expr);
 		case EXPR_BITACCESS:
+		case EXPR_SUBSCRIPT_ASSIGN:
 			UNREACHABLE
 		case EXPR_ACCESS:
 			return sema_expr_analyse_access(context, expr);
@@ -6769,10 +6863,11 @@ bool sema_analyse_inferred_expr(SemaContext *context, Type *infer_type, Expr *ex
 	return true;
 }
 
-bool splitpathref(const char *string, ArraySize len, Path **path_ref, const char **ident_ref, TokenType *type_ref)
+TokenType sema_splitpathref(const char *string, ArraySize len, Path **path_ref, const char **ident_ref)
 {
 	ArraySize path_end = 0;
 	*path_ref = NULL;
+	*ident_ref = NULL;
 	for (ArraySize i = 0; i < len; i++)
 	{
 		char ch = string[i];
@@ -6785,7 +6880,7 @@ bool splitpathref(const char *string, ArraySize len, Path **path_ref, const char
 			}
 			else
 			{
-				return false;
+				return TOKEN_INVALID_TOKEN;
 			}
 		}
 	}
@@ -6802,23 +6897,30 @@ bool splitpathref(const char *string, ArraySize len, Path **path_ref, const char
 		len--;
 		string++;
 	}
-	if (len == 0) return false;
+	if (len == 0) return TOKEN_INVALID_TOKEN;
 	uint32_t hash = FNV1_SEED;
 	for (size_t i = 0; i < len; i++)
 	{
 		char c = string[i];
-		if (!char_is_alphanum_(c)) return false;
+		if (!char_is_alphanum_(c)) return TOKEN_INVALID_TOKEN;
 		hash = FNV1a(c, hash);
 	}
-	*ident_ref = symtab_find(string, len, hash, type_ref);
-	if (!*ident_ref)
+	TokenType type;
+	*ident_ref = symtab_find(string, len, hash, &type);
+	if (!*ident_ref) return TOKEN_IDENT;
+	switch (type)
 	{
-		scratch_buffer_clear();
-		scratch_buffer_append_len(string, len);
-		*ident_ref = scratch_buffer_to_string();
-		*type_ref = TOKEN_INVALID_TOKEN;
+		case TOKEN_TYPE_IDENT:
+		case TOKEN_IDENT:
+		case TOKEN_CONST_IDENT:
+			return type;
+		case TYPE_TOKENS:
+			if (!*path_ref) return type;
+			FALLTHROUGH;
+		default:
+			*ident_ref = NULL;
+			return TOKEN_INVALID_TOKEN;
 	}
-	return true;
 }
 
 bool sema_insert_method_call(SemaContext *context, Expr *method_call, Decl *method_decl, Expr *parent, Expr **arguments)
diff --git a/src/compiler/sema_internal.h b/src/compiler/sema_internal.h
index 8e25af6c5..83db2c76b 100644
--- a/src/compiler/sema_internal.h
+++ b/src/compiler/sema_internal.h
@@ -27,6 +27,17 @@
 #define POP_BREAKCONT() POP_CONTINUE(); POP_BREAK()
 #define IS_CONST(_x) ((_x)->expr_kind == EXPR_CONST)
 
+typedef enum
+{
+	SPLIT_PATH_IDENT,
+	SPLIT_PATH_CONST_IDENT,
+	SPLIT_PATH_TYPE_IDENT,
+	SPLIT_PATH_BUILTIN_TYPE_IDENT,
+	SPLIT_PATH_UNKNOWN_IDENTIFIER,
+	SPLIT_PATH_NOT_SINGLE_IDENTIFIER,
+	SPLIT_PATH_NOT_AN_IDENTIFIER,
+} SplitPathResult;
+
 extern const char *ct_eval_error;
 
 Decl **global_context_acquire_locals_list(void);
@@ -38,7 +49,8 @@ void context_pop_defers_and_replace_ast(SemaContext *context, Ast *ast);
 void context_change_scope_for_label(SemaContext *context, Decl *label);
 void context_change_scope_with_flags(SemaContext *context, ScopeFlags flags);
 SemaContext *context_transform_for_eval(SemaContext *context, SemaContext *temp_context, CompilationUnit *eval_unit);
-bool splitpathref(const char *string, ArraySize len, Path **path_ref, const char **ident_ref, TokenType *type_ref);
+
+TokenType sema_splitpathref(const char *string, ArraySize len, Path **path_ref, const char **ident_ref);
 
 void sema_context_init(SemaContext *context, CompilationUnit *unit);
 void sema_context_destroy(SemaContext *context);
@@ -65,7 +77,7 @@ bool sema_insert_method_call(SemaContext *context, Expr *method_call, Decl *meth
 bool sema_expr_analyse_builtin_call(SemaContext *context, Expr *expr);
 bool sema_expr_analyse_macro_call(SemaContext *context, Expr *call_expr, Expr *struct_var, Decl *decl, bool failable);
 Expr *sema_expr_analyse_ct_arg_index(SemaContext *context, Expr *index_expr);
-const char *sema_ct_eval_expr(SemaContext *c, const char *expr_type, Expr *inner, TokenType *type, Path **path_ref, bool report_missing);
+Expr *sema_ct_eval_expr(SemaContext *c, bool is_type, Expr *inner, bool report_missing);
 bool sema_analyse_asm(SemaContext *context, AsmInlineBlock *block, Ast *asm_stmt);
 bool sema_bit_assignment_check(Expr *right, Decl *member);
 int sema_check_comp_time_bool(SemaContext *context, Expr *expr);
diff --git a/src/compiler/sema_types.c b/src/compiler/sema_types.c
index 7c165df77..c82f7a0aa 100644
--- a/src/compiler/sema_types.c
+++ b/src/compiler/sema_types.c
@@ -273,7 +273,6 @@ bool sema_resolve_type_shallow(SemaContext *context, TypeInfo *type_info, bool a
 		allow_inferred_type = false;
 		in_shallow = true;
 	}
-RETRY:
 	switch (type_info->kind)
 	{
 		case TYPE_INFO_POISON:
@@ -301,29 +300,18 @@ RETRY:
 		{
 			Expr *expr = type_info->unresolved_type_expr;
 			TokenType type;
-			Path *path = NULL;
-			const char *ident = sema_ct_eval_expr(context, "$eval", expr, &type, &path, true);
-			if (ident == ct_eval_error) return type_info_poison(type_info);
-			switch (type)
+			Expr *inner = sema_ct_eval_expr(context, "$evaltype", expr, true);
+			if (!inner) return false;
+			if (inner->expr_kind != EXPR_TYPEINFO)
 			{
-				case TOKEN_TYPE_IDENT:
-					type_info->unresolved.name = ident;
-					type_info->span = expr->span;
-					type_info->unresolved.path = path;
-					type_info->kind = TYPE_INFO_IDENTIFIER;
-					goto RETRY;
-				case TYPE_TOKENS:
-					if (path)
-					{
-						SEMA_ERROR(path, "Built in types cannot have a path prefix.");
-						return false;
-					}
-					type_info->type = type_from_token(type);
-					goto APPEND_QUALIFIERS;
-				default:
-					SEMA_ERROR(expr, "Only type names may be resolved with $evaltype.");
-					return type_info_poison(type_info);
+				SEMA_ERROR(expr, "Only type names may be resolved with $evaltype.");
+				return type_info_poison(type_info);
 			}
+			TypeInfo *inner_type = inner->type_expr;
+			if (!sema_resolve_type_info(context, inner_type)) return false;
+			type_info->type = inner_type->type;
+			type_info->resolve_status = RESOLVE_DONE;
+			goto APPEND_QUALIFIERS;
 		}
 		case TYPE_INFO_TYPEOF:
 		{
diff --git a/src/compiler/semantic_analyser.c b/src/compiler/semantic_analyser.c
index 939a5541a..7ffb72b3d 100644
--- a/src/compiler/semantic_analyser.c
+++ b/src/compiler/semantic_analyser.c
@@ -285,7 +285,7 @@ void sema_analysis_run(void)
 		Path *path;
 		const char *ident;
 		TokenType type;
-		if (!splitpathref(panicfn, strlen(panicfn), &path, &ident, &type) || path == NULL)
+		if (sema_splitpathref(panicfn, strlen(panicfn), &path, &ident) != TOKEN_IDENT || path == NULL || !ident)
 		{
 			error_exit("'%s' is not a valid panic function.", panicfn);
 		}
diff --git a/src/compiler/symtab.c b/src/compiler/symtab.c
index 985358c83..dd8f4b7f5 100644
--- a/src/compiler/symtab.c
+++ b/src/compiler/symtab.c
@@ -41,6 +41,7 @@ const char *builtin_list[NUMBER_OF_BUILTINS];
 
 const char *kw_FILE;
 const char *kw_FUNC;
+const char *kw_FUNCPTR;
 const char *kw_LINEREAL;
 const char *kw_LINE;
 const char *kw_align;
@@ -131,6 +132,7 @@ void symtab_init(uint32_t capacity)
 	kw_LINEREAL = KW_DEF("LINEREAL");
 	kw_FILE = KW_DEF("FILE");
 	kw_FUNC = KW_DEF("FUNC");
+	kw_FUNCPTR = KW_DEF("FUNCPTR");
 
 	type = TOKEN_TYPE_IDENT;
 	kw_typekind = KW_DEF("TypeKind");
diff --git a/src/version.h b/src/version.h
index 15b91d2c6..e2a0aafae 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.3.68"
\ No newline at end of file
+#define COMPILER_VERSION "0.3.69"
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_funcptr.c3t b/test/test_suite/compile_time/ct_funcptr.c3t
new file mode 100644
index 000000000..946a379e3
--- /dev/null
+++ b/test/test_suite/compile_time/ct_funcptr.c3t
@@ -0,0 +1,69 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void test(int x)
+{
+	$typeof($$FUNCPTR) ptr = $$FUNCPTR;
+	io::printfln("%d", x);
+	if (x > 0) ptr(x - 1);
+}
+
+fn void main()
+{
+	test(10);
+}
+
+/* #expect: test.ll
+
+define void @test_test(i32 %0) #0 {
+entry:
+  %ptr = alloca void (i32)*, align 8
+  %retparam = alloca i64, align 8
+  %taddr = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [1 x %variant], align 16
+  %taddr1 = alloca i32, align 4
+  store void (i32)* @test_test, void (i32)** %ptr, align 8
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8
+  %1 = bitcast %"char[]"* %taddr to { i8*, i64 }*
+  %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0
+  %lo = load i8*, i8** %2, align 8
+  %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1
+  %hi = load i64, i64* %3, align 8
+  store i32 %0, i32* %taddr1, align 4
+  %4 = bitcast i32* %taddr1 to i8*
+  %5 = insertvalue %variant undef, i8* %4, 0
+  %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
+  %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
+  store %variant %6, %variant* %7, align 16
+  %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
+  store i64 1, i64* %8, align 8
+  %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
+  %10 = bitcast [1 x %variant]* %varargslots to %variant*
+  store %variant* %10, %variant** %9, align 8
+  %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
+  %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0
+  %lo2 = load i8*, i8** %12, align 8
+  %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1
+  %hi3 = load i64, i64* %13, align 8
+  %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
+  %not_err = icmp eq i64 %14, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %entry
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %entry
+  %gt = icmp sgt i32 %0, 0
+  br i1 %gt, label %if.then, label %if.exit
+
+if.then:                                          ; preds = %voiderr
+  %15 = load void (i32)*, void (i32)** %ptr, align 8
+  %sub = sub i32 %0, 1
+  call void %15(i32 %sub)
+  br label %if.exit
+
+if.exit:                                          ; preds = %if.then, %voiderr
+  ret void
+}
diff --git a/test/test_suite/compile_time_introspection/nameof_err.c3 b/test/test_suite/compile_time_introspection/nameof_err.c3
index bcfacfaef..764f6d41b 100644
--- a/test/test_suite/compile_time_introspection/nameof_err.c3
+++ b/test/test_suite/compile_time_introspection/nameof_err.c3
@@ -16,5 +16,5 @@ fn void main3()
 
 fn void main4()
 {
-    $extnameof($evaltype("foo::int")); // #error: Built in types cannot have a path prefix.
+    $extnameof($evaltype("foo::int")); // #error: Only valid types may be resolved with $evaltype.
 }
diff --git a/test/test_suite/compile_time_introspection/sizeof_errors.c3 b/test/test_suite/compile_time_introspection/sizeof_errors.c3
index e35060e70..1496dc056 100644
--- a/test/test_suite/compile_time_introspection/sizeof_errors.c3
+++ b/test/test_suite/compile_time_introspection/sizeof_errors.c3
@@ -24,7 +24,7 @@ fn void f()
 
 fn void g()
 {
-    int x = $evaltype("bar::").sizeof; // #error: A valid name was expected here.
+    int x = $evaltype("bar::").sizeof; // #error: Only valid types may be resolved with $evaltype
 }
 
 fn void k()
diff --git a/test/test_suite/overloading/set_overload.c3t b/test/test_suite/overloading/set_overload.c3t
new file mode 100644
index 000000000..c18610fcf
--- /dev/null
+++ b/test/test_suite/overloading/set_overload.c3t
@@ -0,0 +1,39 @@
+// #target: macos-x64
+
+module test;
+import std::map;
+
+define IntMap = HashMap<char[], int>;
+
+fn void main()
+{
+	IntMap map;
+	map.set("Hello", 4);
+	map["Bye"] = 5;
+}
+
+/* #expect: test.ll
+
+define void @test_main() #0 {
+entry:
+  %map = alloca %HashMap, align 8
+  %taddr = alloca %"char[]", align 8
+  %taddr1 = alloca %"char[]", align 8
+  %0 = bitcast %HashMap* %map to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 40, i1 false)
+  store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr, align 8
+  %1 = bitcast %"char[]"* %taddr to { i8*, i64 }*
+  %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0
+  %lo = load i8*, i8** %2, align 8
+  %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1
+  %hi = load i64, i64* %3, align 8
+  %4 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* %lo, i64 %hi, i32 4)
+  store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3 }, %"char[]"* %taddr1, align 8
+  %5 = bitcast %"char[]"* %taddr1 to { i8*, i64 }*
+  %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0
+  %lo2 = load i8*, i8** %6, align 8
+  %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1
+  %hi3 = load i64, i64* %7, align 8
+  %8 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* %lo2, i64 %hi3, i32 5)
+  ret void
+}
diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t
index b35ba3a1c..4d8a25205 100644
--- a/test/test_suite/stdlib/map.c3t
+++ b/test/test_suite/stdlib/map.c3t
@@ -46,10 +46,10 @@ fn void main()
 	@pool()
 	{
 		IntDoubleMap map3;
-		map3.init(.allocator = mem::temp_allocator());
+		map3.init();
 		map3.set(5, 3.2);
 		map3.set(7, 5.2);
-		io::printfln("%s", map3.key_tlist());
+		io::printfln("%s", map3.key_list());
 	};
 }
 
@@ -60,17 +60,46 @@ fn void main()
 
 define internal void @.static_initialize.0() {
 entry:
+  %error_var = alloca i64, align 8
+  %retparam = alloca %TempAllocator*, align 8
   %0 = load i64, i64* getelementptr inbounds (%HashMap, %HashMap* @std_io_tostring_functions, i32 0, i32 0, i32 1), align 8
   %not = icmp eq i64 %0, 0
-  br i1 %not, label %if.then, label %if.exit
+  br i1 %not, label %if.then, label %if.exit3
 
 if.then:                                          ; preds = %entry
-  %1 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(%HashMap* @std_io_tostring_functions, i32 512, float 7.500000e-01, %Allocator* %1)
+  %1 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not1 = icmp eq %TempAllocator* %1, null
+  br i1 %not1, label %if.then2, label %if.exit
+
+if.then2:                                         ; preds = %if.then
+  %2 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err = icmp eq i64 %2, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then2
+  store i64 %2, i64* %error_var, align 8
+  br label %panic_block
+
+after_check:                                      ; preds = %if.then2
+  %3 = load %TempAllocator*, %TempAllocator** %retparam, align 8
+  br label %noerr_block
+
+panic_block:                                      ; preds = %assign_optional
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.zstr.2, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block:                                      ; preds = %after_check
+  store %TempAllocator* %3, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %entry
-  %2 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(%HashMap* @std_io_tostring_functions, i64 ptrtoint (%.introspect* @"ct$test_Foo" to i64), { i8*, i64 } (i8*, %Allocator*)* bitcast ({ i8*, i64 } (%Foo*, %Allocator*)* @test_Foo_to_string to { i8*, i64 } (i8*, %Allocator*)*))
+if.exit:                                          ; preds = %noerr_block, %if.then
+  %4 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr = bitcast %TempAllocator* %4 to %Allocator*
+  call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(%HashMap* @std_io_tostring_functions, i32 512, float 7.500000e-01, %Allocator* %ptrptr)
+  br label %if.exit3
+
+if.exit3:                                         ; preds = %if.exit, %entry
+  %5 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(%HashMap* @std_io_tostring_functions, i64 ptrtoint (%.introspect* @"ct$test_Foo" to i64), { i8*, i64 } (i8*, %Allocator*)* bitcast ({ i8*, i64 } (%Foo*, %Allocator*)* @test_Foo_to_string to { i8*, i64 } (i8*, %Allocator*)*))
   ret void
 }
 
@@ -85,7 +114,7 @@ entry:
   %tempcoerce = alloca { i8*, i64 }, align 8
   %2 = call i8* @std_core_string_new_with_capacity(i64 128, %Allocator* %1)
   store i8* %2, i8** %s, align 8
-  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
+  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.38, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
   %3 = bitcast %"char[]"* %taddr to { i8*, i64 }*
   %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %3, i32 0, i32 0
   %lo = load i8*, i8** %4, align 8
@@ -136,555 +165,733 @@ voiderr:                                          ; preds = %after_check, %entry
 define void @test_main() #0 {
 entry:
   %map = alloca %HashMap.0, align 8
-  %retparam = alloca i64, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca %TempAllocator*, align 8
+  %retparam1 = alloca i64, align 8
   %taddr = alloca %"char[]", align 8
   %vararg = alloca %"variant[]", align 8
   %varargslots = alloca [1 x %variant], align 16
   %literal = alloca %Foo, align 8
-  %retparam5 = alloca i64, align 8
-  %taddr6 = alloca %"char[]", align 8
-  %vararg9 = alloca %"variant[]", align 8
-  %varargslots10 = alloca [1 x %variant], align 16
-  %literal16 = alloca %Foo, align 8
-  %retparam19 = alloca i64, align 8
-  %taddr20 = alloca %"char[]", align 8
-  %vararg23 = alloca %"variant[]", align 8
-  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam30 = alloca i64, align 8
-  %taddr31 = alloca %"char[]", align 8
-  %vararg34 = alloca %"variant[]", align 8
-  %varargslots35 = alloca [1 x %variant], align 16
-  %retparam36 = alloca %Foo, align 8
-  %retparam44 = alloca i64, align 8
-  %taddr45 = alloca %"char[]", align 8
-  %vararg48 = alloca %"variant[]", align 8
-  %varargslots49 = alloca [1 x %variant], align 16
-  %taddr50 = alloca i8, align 1
-  %retparam56 = alloca i64, align 8
-  %taddr57 = alloca %"char[]", align 8
-  %vararg60 = alloca %"variant[]", align 8
-  %varargslots61 = alloca [1 x %variant], align 16
-  %taddr62 = alloca i8, align 1
-  %literal68 = alloca %Foo, align 8
-  %retparam71 = alloca i64, align 8
-  %taddr72 = alloca %"char[]", align 8
-  %vararg75 = alloca %"variant[]", align 8
-  %varargslots76 = alloca [1 x %variant], align 16
+  %retparam8 = alloca i64, align 8
+  %taddr9 = alloca %"char[]", align 8
+  %vararg12 = alloca %"variant[]", align 8
+  %varargslots13 = alloca [1 x %variant], align 16
+  %literal19 = alloca %Foo, align 8
+  %retparam22 = alloca i64, align 8
+  %taddr23 = alloca %"char[]", align 8
+  %vararg26 = alloca %"variant[]", align 8
+  %varargslots27 = alloca [1 x %variant], align 16
+  %retparam33 = alloca i64, align 8
+  %taddr34 = alloca %"char[]", align 8
+  %vararg37 = alloca %"variant[]", align 8
+  %varargslots38 = alloca [1 x %variant], align 16
+  %retparam39 = alloca %Foo, align 8
+  %retparam47 = alloca i64, align 8
+  %taddr48 = alloca %"char[]", align 8
+  %vararg51 = alloca %"variant[]", align 8
+  %varargslots52 = alloca [1 x %variant], align 16
+  %taddr53 = alloca i8, align 1
+  %retparam59 = alloca i64, align 8
+  %taddr60 = alloca %"char[]", align 8
+  %vararg63 = alloca %"variant[]", align 8
+  %varargslots64 = alloca [1 x %variant], align 16
+  %taddr65 = alloca i8, align 1
+  %literal71 = alloca %Foo, align 8
+  %retparam74 = alloca i64, align 8
+  %taddr75 = alloca %"char[]", align 8
+  %vararg78 = alloca %"variant[]", align 8
+  %varargslots79 = alloca [1 x %variant], align 16
+  %error_var82 = alloca i64, align 8
+  %retparam83 = alloca %TempAllocator*, align 8
   %result = alloca %"Foo[]", align 8
   %map2 = alloca %HashMap.3, align 8
-  %retparam82 = alloca i64, align 8
-  %taddr83 = alloca %"char[]", align 8
-  %vararg86 = alloca %"variant[]", align 8
-  %varargslots87 = alloca [1 x %variant], align 16
-  %taddr88 = alloca i8, align 1
-  %retparam94 = alloca i64, align 8
-  %taddr95 = alloca %"char[]", align 8
-  %vararg98 = alloca %"variant[]", align 8
-  %varargslots99 = alloca [1 x %variant], align 16
-  %taddr100 = alloca i8, align 1
-  %retparam106 = alloca i64, align 8
-  %taddr107 = alloca %"char[]", align 8
-  %vararg110 = alloca %"variant[]", align 8
-  %varargslots111 = alloca [1 x %variant], align 16
-  %result112 = alloca %"int[]", align 8
-  %retparam118 = alloca i64, align 8
-  %taddr119 = alloca %"char[]", align 8
-  %vararg122 = alloca %"variant[]", align 8
-  %varargslots123 = alloca [1 x %variant], align 16
-  %result124 = alloca %"double[]", align 8
+  %error_var98 = alloca i64, align 8
+  %retparam99 = alloca %TempAllocator*, align 8
+  %retparam107 = alloca i64, align 8
+  %taddr108 = alloca %"char[]", align 8
+  %vararg111 = alloca %"variant[]", align 8
+  %varargslots112 = alloca [1 x %variant], align 16
+  %taddr113 = alloca i8, align 1
+  %retparam119 = alloca i64, align 8
+  %taddr120 = alloca %"char[]", align 8
+  %vararg123 = alloca %"variant[]", align 8
+  %varargslots124 = alloca [1 x %variant], align 16
+  %taddr125 = alloca i8, align 1
+  %retparam131 = alloca i64, align 8
+  %taddr132 = alloca %"char[]", align 8
+  %vararg135 = alloca %"variant[]", align 8
+  %varargslots136 = alloca [1 x %variant], align 16
+  %error_var139 = alloca i64, align 8
+  %retparam140 = alloca %TempAllocator*, align 8
+  %result148 = alloca %"int[]", align 8
+  %retparam154 = alloca i64, align 8
+  %taddr155 = alloca %"char[]", align 8
+  %vararg158 = alloca %"variant[]", align 8
+  %varargslots159 = alloca [1 x %variant], align 16
+  %error_var162 = alloca i64, align 8
+  %retparam163 = alloca %TempAllocator*, align 8
+  %result171 = alloca %"double[]", align 8
   %temp = alloca %TempAllocator*, align 8
-  %error_var = alloca i64, align 8
-  %retparam130 = alloca %TempAllocator*, align 8
+  %error_var179 = alloca i64, align 8
+  %retparam180 = alloca %TempAllocator*, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.3, align 8
-  %error_var135 = alloca i64, align 8
-  %retparam136 = alloca %TempAllocator*, align 8
-  %retparam143 = alloca i64, align 8
-  %taddr144 = alloca %"char[]", align 8
-  %vararg147 = alloca %"variant[]", align 8
-  %varargslots148 = alloca [1 x %variant], align 16
-  %result149 = alloca %"int[]", align 8
+  %error_var189 = alloca i64, align 8
+  %retparam190 = alloca %TempAllocator*, align 8
+  %retparam198 = alloca i64, align 8
+  %taddr199 = alloca %"char[]", align 8
+  %vararg202 = alloca %"variant[]", align 8
+  %varargslots203 = alloca [1 x %variant], align 16
+  %error_var206 = alloca i64, align 8
+  %retparam207 = alloca %TempAllocator*, align 8
+  %result215 = alloca %"int[]", align 8
   %0 = bitcast %HashMap.0* %map to i8*
   call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 40, i1 false)
-  %1 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$int.test_Foo_HashMap_init"(%HashMap.0* %map, i32 16, float 7.500000e-01, %Allocator* %1)
-  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i64 12 }, %"char[]"* %taddr, align 8
-  %2 = bitcast %"char[]"* %taddr to { i8*, i64 }*
-  %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0
-  %lo = load i8*, i8** %3, align 8
-  %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1
-  %hi = load i64, i64* %4, align 8
-  %5 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
-  %6 = bitcast i32* %5 to i8*
-  %7 = insertvalue %variant undef, i8* %6, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
-  %9 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
-  store %variant %8, %variant* %9, align 16
-  %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
-  store i64 1, i64* %10, align 8
-  %11 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
-  %12 = bitcast [1 x %variant]* %varargslots to %variant*
-  store %variant* %12, %variant** %11, align 8
-  %13 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
-  %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 0
-  %lo1 = load i8*, i8** %14, align 8
-  %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 1
-  %hi2 = load i64, i64* %15, align 8
-  %16 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2)
-  %not_err = icmp eq i64 %16, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
-  %17 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
-  store i32 1, i32* %17, align 8
-  %18 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
-  store i8* null, i8** %18, align 8
-  %19 = bitcast %Foo* %literal to { i64, i8* }*
-  %20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %19, i32 0, i32 0
-  %lo3 = load i64, i64* %20, align 8
-  %21 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %19, i32 0, i32 1
-  %hi4 = load i8*, i8** %21, align 8
-  %22 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo3, i8* %hi4)
-  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i32 0, i32 0), i64 12 }, %"char[]"* %taddr6, align 8
-  %23 = bitcast %"char[]"* %taddr6 to { i8*, i64 }*
-  %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %23, i32 0, i32 0
-  %lo7 = load i8*, i8** %24, align 8
-  %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %23, i32 0, i32 1
-  %hi8 = load i64, i64* %25, align 8
-  %26 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
-  %27 = bitcast i32* %26 to i8*
-  %28 = insertvalue %variant undef, i8* %27, 0
-  %29 = insertvalue %variant %28, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
-  %30 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots10, i64 0, i64 0
-  store %variant %29, %variant* %30, align 16
-  %31 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1
-  store i64 1, i64* %31, align 8
-  %32 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0
-  %33 = bitcast [1 x %variant]* %varargslots10 to %variant*
-  store %variant* %33, %variant** %32, align 8
-  %34 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }*
-  %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 0
-  %lo11 = load i8*, i8** %35, align 8
-  %36 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 1
-  %hi12 = load i64, i64* %36, align 8
-  %37 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12)
-  %not_err13 = icmp eq i64 %37, 0
-  br i1 %not_err13, label %after_check14, label %voiderr15
-
-after_check14:                                    ; preds = %voiderr
-  br label %voiderr15
-
-voiderr15:                                        ; preds = %after_check14, %voiderr
-  %38 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 0
-  store i32 2, i32* %38, align 8
-  %39 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 1
-  store i8* null, i8** %39, align 8
-  %40 = bitcast %Foo* %literal16 to { i64, i8* }*
-  %41 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %40, i32 0, i32 0
-  %lo17 = load i64, i64* %41, align 8
-  %42 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %40, i32 0, i32 1
-  %hi18 = load i8*, i8** %42, align 8
-  %43 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo17, i8* %hi18)
-  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), i64 12 }, %"char[]"* %taddr20, align 8
-  %44 = bitcast %"char[]"* %taddr20 to { i8*, i64 }*
-  %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0
-  %lo21 = load i8*, i8** %45, align 8
-  %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1
-  %hi22 = load i64, i64* %46, align 8
-  %47 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
-  %48 = bitcast i32* %47 to i8*
-  %49 = insertvalue %variant undef, i8* %48, 0
-  %50 = insertvalue %variant %49, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
-  %51 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0
-  store %variant %50, %variant* %51, align 16
-  %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1
-  store i64 1, i64* %52, align 8
-  %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0
-  %54 = bitcast [1 x %variant]* %varargslots24 to %variant*
-  store %variant* %54, %variant** %53, align 8
-  %55 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }*
-  %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0
-  %lo25 = load i8*, i8** %56, align 8
-  %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1
-  %hi26 = load i64, i64* %57, align 8
-  %58 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26)
-  %not_err27 = icmp eq i64 %58, 0
-  br i1 %not_err27, label %after_check28, label %voiderr29
-
-after_check28:                                    ; preds = %voiderr15
-  br label %voiderr29
-
-voiderr29:                                        ; preds = %after_check28, %voiderr15
-  store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i64 7 }, %"char[]"* %taddr31, align 8
-  %59 = bitcast %"char[]"* %taddr31 to { i8*, i64 }*
-  %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %59, i32 0, i32 0
-  %lo32 = load i8*, i8** %60, align 8
-  %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %59, i32 0, i32 1
-  %hi33 = load i64, i64* %61, align 8
-  %62 = call i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo* %retparam36, %HashMap.0* %map, i32 1)
-  %not_err37 = icmp eq i64 %62, 0
-  br i1 %not_err37, label %after_check38, label %voiderr43
-
-after_check38:                                    ; preds = %voiderr29
-  %63 = getelementptr inbounds %Foo, %Foo* %retparam36, i32 0, i32 0
-  %64 = bitcast i32* %63 to i8*
-  %65 = insertvalue %variant undef, i8* %64, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
-  %67 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots35, i64 0, i64 0
-  store %variant %66, %variant* %67, align 16
-  %68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1
-  store i64 1, i64* %68, align 8
-  %69 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0
-  %70 = bitcast [1 x %variant]* %varargslots35 to %variant*
-  store %variant* %70, %variant** %69, align 8
-  %71 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }*
-  %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 0
-  %lo39 = load i8*, i8** %72, align 8
-  %73 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 1
-  %hi40 = load i64, i64* %73, align 8
-  %74 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo39, i64 %hi40)
-  %not_err41 = icmp eq i64 %74, 0
-  br i1 %not_err41, label %after_check42, label %voiderr43
-
-after_check42:                                    ; preds = %after_check38
-  br label %voiderr43
-
-voiderr43:                                        ; preds = %after_check42, %after_check38, %voiderr29
-  store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i64 9 }, %"char[]"* %taddr45, align 8
-  %75 = bitcast %"char[]"* %taddr45 to { i8*, i64 }*
-  %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 0
-  %lo46 = load i8*, i8** %76, align 8
-  %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 1
-  %hi47 = load i64, i64* %77, align 8
-  %78 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 1)
-  store i8 %78, i8* %taddr50, align 1
-  %79 = insertvalue %variant undef, i8* %taddr50, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
-  %81 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0
-  store %variant %80, %variant* %81, align 16
-  %82 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1
-  store i64 1, i64* %82, align 8
-  %83 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0
-  %84 = bitcast [1 x %variant]* %varargslots49 to %variant*
-  store %variant* %84, %variant** %83, align 8
-  %85 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }*
-  %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 0
-  %lo51 = load i8*, i8** %86, align 8
-  %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 1
-  %hi52 = load i64, i64* %87, align 8
-  %88 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo51, i64 %hi52)
-  %not_err53 = icmp eq i64 %88, 0
-  br i1 %not_err53, label %after_check54, label %voiderr55
-
-after_check54:                                    ; preds = %voiderr43
-  br label %voiderr55
-
-voiderr55:                                        ; preds = %after_check54, %voiderr43
-  store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i32 0, i32 0), i64 9 }, %"char[]"* %taddr57, align 8
-  %89 = bitcast %"char[]"* %taddr57 to { i8*, i64 }*
-  %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 0
-  %lo58 = load i8*, i8** %90, align 8
-  %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 1
-  %hi59 = load i64, i64* %91, align 8
-  %92 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 2)
-  store i8 %92, i8* %taddr62, align 1
-  %93 = insertvalue %variant undef, i8* %taddr62, 0
-  %94 = insertvalue %variant %93, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
-  %95 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots61, i64 0, i64 0
-  store %variant %94, %variant* %95, align 16
-  %96 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 1
-  store i64 1, i64* %96, align 8
-  %97 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 0
-  %98 = bitcast [1 x %variant]* %varargslots61 to %variant*
-  store %variant* %98, %variant** %97, align 8
-  %99 = bitcast %"variant[]"* %vararg60 to { i8*, i64 }*
-  %100 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 0
-  %lo63 = load i8*, i8** %100, align 8
-  %101 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 1
-  %hi64 = load i64, i64* %101, align 8
-  %102 = call i64 @std_io_printfln(i64* %retparam56, i8* %lo58, i64 %hi59, i8* %lo63, i64 %hi64)
-  %not_err65 = icmp eq i64 %102, 0
-  br i1 %not_err65, label %after_check66, label %voiderr67
-
-after_check66:                                    ; preds = %voiderr55
-  br label %voiderr67
-
-voiderr67:                                        ; preds = %after_check66, %voiderr55
-  %103 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 0
-  store i32 4, i32* %103, align 8
-  %104 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 1
-  store i8* null, i8** %104, align 8
-  %105 = bitcast %Foo* %literal68 to { i64, i8* }*
-  %106 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %105, i32 0, i32 0
-  %lo69 = load i64, i64* %106, align 8
-  %107 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %105, i32 0, i32 1
-  %hi70 = load i8*, i8** %107, align 8
-  %108 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 7, i64 %lo69, i8* %hi70)
-  store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i64 10 }, %"char[]"* %taddr72, align 8
-  %109 = bitcast %"char[]"* %taddr72 to { i8*, i64 }*
-  %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 0
-  %lo73 = load i8*, i8** %110, align 8
-  %111 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 1
-  %hi74 = load i64, i64* %111, align 8
-  %112 = call { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0* %map, %Allocator* null)
-  %113 = bitcast %"Foo[]"* %result to { i8*, i64 }*
-  store { i8*, i64 } %112, { i8*, i64 }* %113, align 8
-  %114 = bitcast %"Foo[]"* %result to i8*
-  %115 = insertvalue %variant undef, i8* %114, 0
-  %116 = insertvalue %variant %115, i64 ptrtoint (%.introspect* @"ct$sa$test_Foo" to i64), 1
-  %117 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots76, i64 0, i64 0
-  store %variant %116, %variant* %117, align 16
-  %118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 1
-  store i64 1, i64* %118, align 8
-  %119 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 0
-  %120 = bitcast [1 x %variant]* %varargslots76 to %variant*
-  store %variant* %120, %variant** %119, align 8
-  %121 = bitcast %"variant[]"* %vararg75 to { i8*, i64 }*
-  %122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 0
-  %lo77 = load i8*, i8** %122, align 8
-  %123 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 1
-  %hi78 = load i64, i64* %123, align 8
-  %124 = call i64 @std_io_printfln(i64* %retparam71, i8* %lo73, i64 %hi74, i8* %lo77, i64 %hi78)
-  %not_err79 = icmp eq i64 %124, 0
-  br i1 %not_err79, label %after_check80, label %voiderr81
-
-after_check80:                                    ; preds = %voiderr67
-  br label %voiderr81
-
-voiderr81:                                        ; preds = %after_check80, %voiderr67
-  %125 = bitcast %HashMap.3* %map2 to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 8 %125, i8 0, i64 40, i1 false)
-  %126 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$int.double_HashMap_init"(%HashMap.3* %map2, i32 16, float 7.500000e-01, %Allocator* %126)
-  %127 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 4, double 1.300000e+00)
-  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i64 12 }, %"char[]"* %taddr83, align 8
-  %128 = bitcast %"char[]"* %taddr83 to { i8*, i64 }*
-  %129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 0
-  %lo84 = load i8*, i8** %129, align 8
-  %130 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 1
-  %hi85 = load i64, i64* %130, align 8
-  %131 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.300000e+00)
-  store i8 %131, i8* %taddr88, align 1
-  %132 = insertvalue %variant undef, i8* %taddr88, 0
-  %133 = insertvalue %variant %132, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
-  %134 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots87, i64 0, i64 0
-  store %variant %133, %variant* %134, align 16
-  %135 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1
-  store i64 1, i64* %135, align 8
-  %136 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0
-  %137 = bitcast [1 x %variant]* %varargslots87 to %variant*
-  store %variant* %137, %variant** %136, align 8
-  %138 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }*
-  %139 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 0
-  %lo89 = load i8*, i8** %139, align 8
-  %140 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 1
-  %hi90 = load i64, i64* %140, align 8
-  %141 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo89, i64 %hi90)
-  %not_err91 = icmp eq i64 %141, 0
-  br i1 %not_err91, label %after_check92, label %voiderr93
-
-after_check92:                                    ; preds = %voiderr81
-  br label %voiderr93
-
-voiderr93:                                        ; preds = %after_check92, %voiderr81
-  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i64 12 }, %"char[]"* %taddr95, align 8
-  %142 = bitcast %"char[]"* %taddr95 to { i8*, i64 }*
-  %143 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %142, i32 0, i32 0
-  %lo96 = load i8*, i8** %143, align 8
-  %144 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %142, i32 0, i32 1
-  %hi97 = load i64, i64* %144, align 8
-  %145 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.200000e+00)
-  store i8 %145, i8* %taddr100, align 1
-  %146 = insertvalue %variant undef, i8* %taddr100, 0
-  %147 = insertvalue %variant %146, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
-  %148 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots99, i64 0, i64 0
-  store %variant %147, %variant* %148, align 16
-  %149 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 1
-  store i64 1, i64* %149, align 8
-  %150 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 0
-  %151 = bitcast [1 x %variant]* %varargslots99 to %variant*
-  store %variant* %151, %variant** %150, align 8
-  %152 = bitcast %"variant[]"* %vararg98 to { i8*, i64 }*
-  %153 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %152, i32 0, i32 0
-  %lo101 = load i8*, i8** %153, align 8
-  %154 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %152, i32 0, i32 1
-  %hi102 = load i64, i64* %154, align 8
-  %155 = call i64 @std_io_printfln(i64* %retparam94, i8* %lo96, i64 %hi97, i8* %lo101, i64 %hi102)
-  %not_err103 = icmp eq i64 %155, 0
-  br i1 %not_err103, label %after_check104, label %voiderr105
-
-after_check104:                                   ; preds = %voiderr93
-  br label %voiderr105
-
-voiderr105:                                       ; preds = %after_check104, %voiderr93
-  %156 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 100, double 3.400000e+00)
-  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2 }, %"char[]"* %taddr107, align 8
-  %157 = bitcast %"char[]"* %taddr107 to { i8*, i64 }*
-  %158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %157, i32 0, i32 0
-  %lo108 = load i8*, i8** %158, align 8
-  %159 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %157, i32 0, i32 1
-  %hi109 = load i64, i64* %159, align 8
-  %160 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map2, %Allocator* null)
-  %161 = bitcast %"int[]"* %result112 to { i8*, i64 }*
-  store { i8*, i64 } %160, { i8*, i64 }* %161, align 8
-  %162 = bitcast %"int[]"* %result112 to i8*
-  %163 = insertvalue %variant undef, i8* %162, 0
-  %164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
-  %165 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots111, i64 0, i64 0
-  store %variant %164, %variant* %165, align 16
-  %166 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 1
-  store i64 1, i64* %166, align 8
-  %167 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 0
-  %168 = bitcast [1 x %variant]* %varargslots111 to %variant*
-  store %variant* %168, %variant** %167, align 8
-  %169 = bitcast %"variant[]"* %vararg110 to { i8*, i64 }*
-  %170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0
-  %lo113 = load i8*, i8** %170, align 8
-  %171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1
-  %hi114 = load i64, i64* %171, align 8
-  %172 = call i64 @std_io_printfln(i64* %retparam106, i8* %lo108, i64 %hi109, i8* %lo113, i64 %hi114)
-  %not_err115 = icmp eq i64 %172, 0
-  br i1 %not_err115, label %after_check116, label %voiderr117
-
-after_check116:                                   ; preds = %voiderr105
-  br label %voiderr117
-
-voiderr117:                                       ; preds = %after_check116, %voiderr105
-  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i64 2 }, %"char[]"* %taddr119, align 8
-  %173 = bitcast %"char[]"* %taddr119 to { i8*, i64 }*
-  %174 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 0
-  %lo120 = load i8*, i8** %174, align 8
-  %175 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 1
-  %hi121 = load i64, i64* %175, align 8
-  %176 = call { i8*, i64 } @"std_map$$int.double_HashMap_value_list"(%HashMap.3* %map2, %Allocator* null)
-  %177 = bitcast %"double[]"* %result124 to { i8*, i64 }*
-  store { i8*, i64 } %176, { i8*, i64 }* %177, align 8
-  %178 = bitcast %"double[]"* %result124 to i8*
-  %179 = insertvalue %variant undef, i8* %178, 0
-  %180 = insertvalue %variant %179, i64 ptrtoint (%.introspect* @"ct$sa$double" to i64), 1
-  %181 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots123, i64 0, i64 0
-  store %variant %180, %variant* %181, align 16
-  %182 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 1
-  store i64 1, i64* %182, align 8
-  %183 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 0
-  %184 = bitcast [1 x %variant]* %varargslots123 to %variant*
-  store %variant* %184, %variant** %183, align 8
-  %185 = bitcast %"variant[]"* %vararg122 to { i8*, i64 }*
-  %186 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %185, i32 0, i32 0
-  %lo125 = load i8*, i8** %186, align 8
-  %187 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %185, i32 0, i32 1
-  %hi126 = load i64, i64* %187, align 8
-  %188 = call i64 @std_io_printfln(i64* %retparam118, i8* %lo120, i64 %hi121, i8* %lo125, i64 %hi126)
-  %not_err127 = icmp eq i64 %188, 0
-  br i1 %not_err127, label %after_check128, label %voiderr129
-
-after_check128:                                   ; preds = %voiderr117
-  br label %voiderr129
-
-voiderr129:                                       ; preds = %after_check128, %voiderr117
-  %189 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
-  %not = icmp eq %TempAllocator* %189, null
+  %1 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not = icmp eq %TempAllocator* %1, null
   br i1 %not, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %voiderr129
-  %190 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam130, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
-  %not_err131 = icmp eq i64 %190, 0
-  br i1 %not_err131, label %after_check132, label %assign_optional
+if.then:                                          ; preds = %entry
+  %2 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err = icmp eq i64 %2, 0
+  br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %if.then
-  store i64 %190, i64* %error_var, align 8
+  store i64 %2, i64* %error_var, align 8
   br label %panic_block
 
-after_check132:                                   ; preds = %if.then
-  %191 = load %TempAllocator*, %TempAllocator** %retparam130, align 8
+after_check:                                      ; preds = %if.then
+  %3 = load %TempAllocator*, %TempAllocator** %retparam, align 8
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
-  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.11, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.12, i64 0, i64 0), i32 250)
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.5, i64 0, i64 0), i32 250)
   unreachable
 
-noerr_block:                                      ; preds = %after_check132
-  store %TempAllocator* %191, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+noerr_block:                                      ; preds = %after_check
+  store %TempAllocator* %3, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
   br label %if.exit
 
-if.exit:                                          ; preds = %noerr_block, %voiderr129
-  %192 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
-  store %TempAllocator* %192, %TempAllocator** %temp, align 8
-  %193 = load %TempAllocator*, %TempAllocator** %temp, align 8
-  %194 = getelementptr inbounds %TempAllocator, %TempAllocator* %193, i32 0, i32 3
-  %195 = load i64, i64* %194, align 8
-  store i64 %195, i64* %mark, align 8
-  %196 = bitcast %HashMap.3* %map3 to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 8 %196, i8 0, i64 40, i1 false)
-  %197 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
-  %not133 = icmp eq %TempAllocator* %197, null
-  br i1 %not133, label %if.then134, label %if.exit142
+if.exit:                                          ; preds = %noerr_block, %entry
+  %4 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr = bitcast %TempAllocator* %4 to %Allocator*
+  call void @"std_map$$int.test_Foo_HashMap_init"(%HashMap.0* %map, i32 16, float 7.500000e-01, %Allocator* %ptrptr)
+  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i64 12 }, %"char[]"* %taddr, align 8
+  %5 = bitcast %"char[]"* %taddr to { i8*, i64 }*
+  %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0
+  %lo = load i8*, i8** %6, align 8
+  %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1
+  %hi = load i64, i64* %7, align 8
+  %8 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
+  %9 = bitcast i32* %8 to i8*
+  %10 = insertvalue %variant undef, i8* %9, 0
+  %11 = insertvalue %variant %10, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
+  %12 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
+  store %variant %11, %variant* %12, align 16
+  %13 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
+  store i64 1, i64* %13, align 8
+  %14 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
+  %15 = bitcast [1 x %variant]* %varargslots to %variant*
+  store %variant* %15, %variant** %14, align 8
+  %16 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
+  %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0
+  %lo2 = load i8*, i8** %17, align 8
+  %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1
+  %hi3 = load i64, i64* %18, align 8
+  %19 = call i64 @std_io_printfln(i64* %retparam1, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
+  %not_err4 = icmp eq i64 %19, 0
+  br i1 %not_err4, label %after_check5, label %voiderr
 
-if.then134:                                       ; preds = %if.exit
-  %198 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam136, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
-  %not_err137 = icmp eq i64 %198, 0
-  br i1 %not_err137, label %after_check139, label %assign_optional138
+after_check5:                                     ; preds = %if.exit
+  br label %voiderr
 
-assign_optional138:                               ; preds = %if.then134
-  store i64 %198, i64* %error_var135, align 8
-  br label %panic_block140
+voiderr:                                          ; preds = %after_check5, %if.exit
+  %20 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
+  store i32 1, i32* %20, align 8
+  %21 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
+  store i8* null, i8** %21, align 8
+  %22 = bitcast %Foo* %literal to { i64, i8* }*
+  %23 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %22, i32 0, i32 0
+  %lo6 = load i64, i64* %23, align 8
+  %24 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %22, i32 0, i32 1
+  %hi7 = load i8*, i8** %24, align 8
+  %25 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo6, i8* %hi7)
+  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i64 12 }, %"char[]"* %taddr9, align 8
+  %26 = bitcast %"char[]"* %taddr9 to { i8*, i64 }*
+  %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0
+  %lo10 = load i8*, i8** %27, align 8
+  %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1
+  %hi11 = load i64, i64* %28, align 8
+  %29 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
+  %30 = bitcast i32* %29 to i8*
+  %31 = insertvalue %variant undef, i8* %30, 0
+  %32 = insertvalue %variant %31, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
+  %33 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots13, i64 0, i64 0
+  store %variant %32, %variant* %33, align 16
+  %34 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg12, i32 0, i32 1
+  store i64 1, i64* %34, align 8
+  %35 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg12, i32 0, i32 0
+  %36 = bitcast [1 x %variant]* %varargslots13 to %variant*
+  store %variant* %36, %variant** %35, align 8
+  %37 = bitcast %"variant[]"* %vararg12 to { i8*, i64 }*
+  %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 0
+  %lo14 = load i8*, i8** %38, align 8
+  %39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 1
+  %hi15 = load i64, i64* %39, align 8
+  %40 = call i64 @std_io_printfln(i64* %retparam8, i8* %lo10, i64 %hi11, i8* %lo14, i64 %hi15)
+  %not_err16 = icmp eq i64 %40, 0
+  br i1 %not_err16, label %after_check17, label %voiderr18
 
-after_check139:                                   ; preds = %if.then134
-  %199 = load %TempAllocator*, %TempAllocator** %retparam136, align 8
-  br label %noerr_block141
+after_check17:                                    ; preds = %voiderr
+  br label %voiderr18
 
-panic_block140:                                   ; preds = %assign_optional138
-  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.13, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.14, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.15, i64 0, i64 0), i32 250)
+voiderr18:                                        ; preds = %after_check17, %voiderr
+  %41 = getelementptr inbounds %Foo, %Foo* %literal19, i32 0, i32 0
+  store i32 2, i32* %41, align 8
+  %42 = getelementptr inbounds %Foo, %Foo* %literal19, i32 0, i32 1
+  store i8* null, i8** %42, align 8
+  %43 = bitcast %Foo* %literal19 to { i64, i8* }*
+  %44 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %43, i32 0, i32 0
+  %lo20 = load i64, i64* %44, align 8
+  %45 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %43, i32 0, i32 1
+  %hi21 = load i8*, i8** %45, align 8
+  %46 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo20, i8* %hi21)
+  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i64 12 }, %"char[]"* %taddr23, align 8
+  %47 = bitcast %"char[]"* %taddr23 to { i8*, i64 }*
+  %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 0
+  %lo24 = load i8*, i8** %48, align 8
+  %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 1
+  %hi25 = load i64, i64* %49, align 8
+  %50 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
+  %51 = bitcast i32* %50 to i8*
+  %52 = insertvalue %variant undef, i8* %51, 0
+  %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
+  %54 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots27, i64 0, i64 0
+  store %variant %53, %variant* %54, align 16
+  %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 1
+  store i64 1, i64* %55, align 8
+  %56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 0
+  %57 = bitcast [1 x %variant]* %varargslots27 to %variant*
+  store %variant* %57, %variant** %56, align 8
+  %58 = bitcast %"variant[]"* %vararg26 to { i8*, i64 }*
+  %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
+  %lo28 = load i8*, i8** %59, align 8
+  %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
+  %hi29 = load i64, i64* %60, align 8
+  %61 = call i64 @std_io_printfln(i64* %retparam22, i8* %lo24, i64 %hi25, i8* %lo28, i64 %hi29)
+  %not_err30 = icmp eq i64 %61, 0
+  br i1 %not_err30, label %after_check31, label %voiderr32
+
+after_check31:                                    ; preds = %voiderr18
+  br label %voiderr32
+
+voiderr32:                                        ; preds = %after_check31, %voiderr18
+  store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0), i64 7 }, %"char[]"* %taddr34, align 8
+  %62 = bitcast %"char[]"* %taddr34 to { i8*, i64 }*
+  %63 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %62, i32 0, i32 0
+  %lo35 = load i8*, i8** %63, align 8
+  %64 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %62, i32 0, i32 1
+  %hi36 = load i64, i64* %64, align 8
+  %65 = call i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo* %retparam39, %HashMap.0* %map, i32 1)
+  %not_err40 = icmp eq i64 %65, 0
+  br i1 %not_err40, label %after_check41, label %voiderr46
+
+after_check41:                                    ; preds = %voiderr32
+  %66 = getelementptr inbounds %Foo, %Foo* %retparam39, i32 0, i32 0
+  %67 = bitcast i32* %66 to i8*
+  %68 = insertvalue %variant undef, i8* %67, 0
+  %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
+  %70 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots38, i64 0, i64 0
+  store %variant %69, %variant* %70, align 16
+  %71 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg37, i32 0, i32 1
+  store i64 1, i64* %71, align 8
+  %72 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg37, i32 0, i32 0
+  %73 = bitcast [1 x %variant]* %varargslots38 to %variant*
+  store %variant* %73, %variant** %72, align 8
+  %74 = bitcast %"variant[]"* %vararg37 to { i8*, i64 }*
+  %75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0
+  %lo42 = load i8*, i8** %75, align 8
+  %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1
+  %hi43 = load i64, i64* %76, align 8
+  %77 = call i64 @std_io_printfln(i64* %retparam33, i8* %lo35, i64 %hi36, i8* %lo42, i64 %hi43)
+  %not_err44 = icmp eq i64 %77, 0
+  br i1 %not_err44, label %after_check45, label %voiderr46
+
+after_check45:                                    ; preds = %after_check41
+  br label %voiderr46
+
+voiderr46:                                        ; preds = %after_check45, %after_check41, %voiderr32
+  store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i32 0, i32 0), i64 9 }, %"char[]"* %taddr48, align 8
+  %78 = bitcast %"char[]"* %taddr48 to { i8*, i64 }*
+  %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0
+  %lo49 = load i8*, i8** %79, align 8
+  %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1
+  %hi50 = load i64, i64* %80, align 8
+  %81 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 1)
+  store i8 %81, i8* %taddr53, align 1
+  %82 = insertvalue %variant undef, i8* %taddr53, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
+  %84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots52, i64 0, i64 0
+  store %variant %83, %variant* %84, align 16
+  %85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 1
+  store i64 1, i64* %85, align 8
+  %86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 0
+  %87 = bitcast [1 x %variant]* %varargslots52 to %variant*
+  store %variant* %87, %variant** %86, align 8
+  %88 = bitcast %"variant[]"* %vararg51 to { i8*, i64 }*
+  %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0
+  %lo54 = load i8*, i8** %89, align 8
+  %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1
+  %hi55 = load i64, i64* %90, align 8
+  %91 = call i64 @std_io_printfln(i64* %retparam47, i8* %lo49, i64 %hi50, i8* %lo54, i64 %hi55)
+  %not_err56 = icmp eq i64 %91, 0
+  br i1 %not_err56, label %after_check57, label %voiderr58
+
+after_check57:                                    ; preds = %voiderr46
+  br label %voiderr58
+
+voiderr58:                                        ; preds = %after_check57, %voiderr46
+  store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0), i64 9 }, %"char[]"* %taddr60, align 8
+  %92 = bitcast %"char[]"* %taddr60 to { i8*, i64 }*
+  %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0
+  %lo61 = load i8*, i8** %93, align 8
+  %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1
+  %hi62 = load i64, i64* %94, align 8
+  %95 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 2)
+  store i8 %95, i8* %taddr65, align 1
+  %96 = insertvalue %variant undef, i8* %taddr65, 0
+  %97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
+  %98 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots64, i64 0, i64 0
+  store %variant %97, %variant* %98, align 16
+  %99 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg63, i32 0, i32 1
+  store i64 1, i64* %99, align 8
+  %100 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg63, i32 0, i32 0
+  %101 = bitcast [1 x %variant]* %varargslots64 to %variant*
+  store %variant* %101, %variant** %100, align 8
+  %102 = bitcast %"variant[]"* %vararg63 to { i8*, i64 }*
+  %103 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 0
+  %lo66 = load i8*, i8** %103, align 8
+  %104 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 1
+  %hi67 = load i64, i64* %104, align 8
+  %105 = call i64 @std_io_printfln(i64* %retparam59, i8* %lo61, i64 %hi62, i8* %lo66, i64 %hi67)
+  %not_err68 = icmp eq i64 %105, 0
+  br i1 %not_err68, label %after_check69, label %voiderr70
+
+after_check69:                                    ; preds = %voiderr58
+  br label %voiderr70
+
+voiderr70:                                        ; preds = %after_check69, %voiderr58
+  %106 = getelementptr inbounds %Foo, %Foo* %literal71, i32 0, i32 0
+  store i32 4, i32* %106, align 8
+  %107 = getelementptr inbounds %Foo, %Foo* %literal71, i32 0, i32 1
+  store i8* null, i8** %107, align 8
+  %108 = bitcast %Foo* %literal71 to { i64, i8* }*
+  %109 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %108, i32 0, i32 0
+  %lo72 = load i64, i64* %109, align 8
+  %110 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %108, i32 0, i32 1
+  %hi73 = load i8*, i8** %110, align 8
+  %111 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 7, i64 %lo72, i8* %hi73)
+  store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i32 0, i32 0), i64 10 }, %"char[]"* %taddr75, align 8
+  %112 = bitcast %"char[]"* %taddr75 to { i8*, i64 }*
+  %113 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %112, i32 0, i32 0
+  %lo76 = load i8*, i8** %113, align 8
+  %114 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %112, i32 0, i32 1
+  %hi77 = load i64, i64* %114, align 8
+  %115 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not80 = icmp eq %TempAllocator* %115, null
+  br i1 %not80, label %if.then81, label %if.exit89
+
+if.then81:                                        ; preds = %voiderr70
+  %116 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam83, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err84 = icmp eq i64 %116, 0
+  br i1 %not_err84, label %after_check86, label %assign_optional85
+
+assign_optional85:                                ; preds = %if.then81
+  store i64 %116, i64* %error_var82, align 8
+  br label %panic_block87
+
+after_check86:                                    ; preds = %if.then81
+  %117 = load %TempAllocator*, %TempAllocator** %retparam83, align 8
+  br label %noerr_block88
+
+panic_block87:                                    ; preds = %assign_optional85
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.12, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.13, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.14, i64 0, i64 0), i32 250)
   unreachable
 
-noerr_block141:                                   ; preds = %after_check139
-  store %TempAllocator* %199, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
-  br label %if.exit142
+noerr_block88:                                    ; preds = %after_check86
+  store %TempAllocator* %117, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit89
 
-if.exit142:                                       ; preds = %noerr_block141, %if.exit
-  %200 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
-  %ptrptr = bitcast %TempAllocator* %200 to %Allocator*
-  call void @"std_map$$int.double_HashMap_init"(%HashMap.3* %map3, i32 16, float 7.500000e-01, %Allocator* %ptrptr)
-  %201 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 5, double 3.200000e+00)
-  %202 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 7, double 5.200000e+00)
-  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i32 0, i32 0), i64 2 }, %"char[]"* %taddr144, align 8
-  %203 = bitcast %"char[]"* %taddr144 to { i8*, i64 }*
+if.exit89:                                        ; preds = %noerr_block88, %voiderr70
+  %118 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr90 = bitcast %TempAllocator* %118 to %Allocator*
+  %119 = call { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0* %map, %Allocator* %ptrptr90)
+  %120 = bitcast %"Foo[]"* %result to { i8*, i64 }*
+  store { i8*, i64 } %119, { i8*, i64 }* %120, align 8
+  %121 = bitcast %"Foo[]"* %result to i8*
+  %122 = insertvalue %variant undef, i8* %121, 0
+  %123 = insertvalue %variant %122, i64 ptrtoint (%.introspect* @"ct$sa$test_Foo" to i64), 1
+  %124 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots79, i64 0, i64 0
+  store %variant %123, %variant* %124, align 16
+  %125 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg78, i32 0, i32 1
+  store i64 1, i64* %125, align 8
+  %126 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg78, i32 0, i32 0
+  %127 = bitcast [1 x %variant]* %varargslots79 to %variant*
+  store %variant* %127, %variant** %126, align 8
+  %128 = bitcast %"variant[]"* %vararg78 to { i8*, i64 }*
+  %129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 0
+  %lo91 = load i8*, i8** %129, align 8
+  %130 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 1
+  %hi92 = load i64, i64* %130, align 8
+  %131 = call i64 @std_io_printfln(i64* %retparam74, i8* %lo76, i64 %hi77, i8* %lo91, i64 %hi92)
+  %not_err93 = icmp eq i64 %131, 0
+  br i1 %not_err93, label %after_check94, label %voiderr95
+
+after_check94:                                    ; preds = %if.exit89
+  br label %voiderr95
+
+voiderr95:                                        ; preds = %after_check94, %if.exit89
+  %132 = bitcast %HashMap.3* %map2 to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 8 %132, i8 0, i64 40, i1 false)
+  %133 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not96 = icmp eq %TempAllocator* %133, null
+  br i1 %not96, label %if.then97, label %if.exit105
+
+if.then97:                                        ; preds = %voiderr95
+  %134 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam99, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err100 = icmp eq i64 %134, 0
+  br i1 %not_err100, label %after_check102, label %assign_optional101
+
+assign_optional101:                               ; preds = %if.then97
+  store i64 %134, i64* %error_var98, align 8
+  br label %panic_block103
+
+after_check102:                                   ; preds = %if.then97
+  %135 = load %TempAllocator*, %TempAllocator** %retparam99, align 8
+  br label %noerr_block104
+
+panic_block103:                                   ; preds = %assign_optional101
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.15, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.16, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.17, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block104:                                   ; preds = %after_check102
+  store %TempAllocator* %135, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit105
+
+if.exit105:                                       ; preds = %noerr_block104, %voiderr95
+  %136 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr106 = bitcast %TempAllocator* %136 to %Allocator*
+  call void @"std_map$$int.double_HashMap_init"(%HashMap.3* %map2, i32 16, float 7.500000e-01, %Allocator* %ptrptr106)
+  %137 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 4, double 1.300000e+00)
+  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i64 12 }, %"char[]"* %taddr108, align 8
+  %138 = bitcast %"char[]"* %taddr108 to { i8*, i64 }*
+  %139 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 0
+  %lo109 = load i8*, i8** %139, align 8
+  %140 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 1
+  %hi110 = load i64, i64* %140, align 8
+  %141 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.300000e+00)
+  store i8 %141, i8* %taddr113, align 1
+  %142 = insertvalue %variant undef, i8* %taddr113, 0
+  %143 = insertvalue %variant %142, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
+  %144 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots112, i64 0, i64 0
+  store %variant %143, %variant* %144, align 16
+  %145 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 1
+  store i64 1, i64* %145, align 8
+  %146 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 0
+  %147 = bitcast [1 x %variant]* %varargslots112 to %variant*
+  store %variant* %147, %variant** %146, align 8
+  %148 = bitcast %"variant[]"* %vararg111 to { i8*, i64 }*
+  %149 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %148, i32 0, i32 0
+  %lo114 = load i8*, i8** %149, align 8
+  %150 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %148, i32 0, i32 1
+  %hi115 = load i64, i64* %150, align 8
+  %151 = call i64 @std_io_printfln(i64* %retparam107, i8* %lo109, i64 %hi110, i8* %lo114, i64 %hi115)
+  %not_err116 = icmp eq i64 %151, 0
+  br i1 %not_err116, label %after_check117, label %voiderr118
+
+after_check117:                                   ; preds = %if.exit105
+  br label %voiderr118
+
+voiderr118:                                       ; preds = %after_check117, %if.exit105
+  store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i64 12 }, %"char[]"* %taddr120, align 8
+  %152 = bitcast %"char[]"* %taddr120 to { i8*, i64 }*
+  %153 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %152, i32 0, i32 0
+  %lo121 = load i8*, i8** %153, align 8
+  %154 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %152, i32 0, i32 1
+  %hi122 = load i64, i64* %154, align 8
+  %155 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.200000e+00)
+  store i8 %155, i8* %taddr125, align 1
+  %156 = insertvalue %variant undef, i8* %taddr125, 0
+  %157 = insertvalue %variant %156, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
+  %158 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots124, i64 0, i64 0
+  store %variant %157, %variant* %158, align 16
+  %159 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg123, i32 0, i32 1
+  store i64 1, i64* %159, align 8
+  %160 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg123, i32 0, i32 0
+  %161 = bitcast [1 x %variant]* %varargslots124 to %variant*
+  store %variant* %161, %variant** %160, align 8
+  %162 = bitcast %"variant[]"* %vararg123 to { i8*, i64 }*
+  %163 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %162, i32 0, i32 0
+  %lo126 = load i8*, i8** %163, align 8
+  %164 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %162, i32 0, i32 1
+  %hi127 = load i64, i64* %164, align 8
+  %165 = call i64 @std_io_printfln(i64* %retparam119, i8* %lo121, i64 %hi122, i8* %lo126, i64 %hi127)
+  %not_err128 = icmp eq i64 %165, 0
+  br i1 %not_err128, label %after_check129, label %voiderr130
+
+after_check129:                                   ; preds = %voiderr118
+  br label %voiderr130
+
+voiderr130:                                       ; preds = %after_check129, %voiderr118
+  %166 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 100, double 3.400000e+00)
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i32 0, i32 0), i64 2 }, %"char[]"* %taddr132, align 8
+  %167 = bitcast %"char[]"* %taddr132 to { i8*, i64 }*
+  %168 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %167, i32 0, i32 0
+  %lo133 = load i8*, i8** %168, align 8
+  %169 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %167, i32 0, i32 1
+  %hi134 = load i64, i64* %169, align 8
+  %170 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not137 = icmp eq %TempAllocator* %170, null
+  br i1 %not137, label %if.then138, label %if.exit146
+
+if.then138:                                       ; preds = %voiderr130
+  %171 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam140, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err141 = icmp eq i64 %171, 0
+  br i1 %not_err141, label %after_check143, label %assign_optional142
+
+assign_optional142:                               ; preds = %if.then138
+  store i64 %171, i64* %error_var139, align 8
+  br label %panic_block144
+
+after_check143:                                   ; preds = %if.then138
+  %172 = load %TempAllocator*, %TempAllocator** %retparam140, align 8
+  br label %noerr_block145
+
+panic_block144:                                   ; preds = %assign_optional142
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.21, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.22, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.23, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block145:                                   ; preds = %after_check143
+  store %TempAllocator* %172, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit146
+
+if.exit146:                                       ; preds = %noerr_block145, %voiderr130
+  %173 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr147 = bitcast %TempAllocator* %173 to %Allocator*
+  %174 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map2, %Allocator* %ptrptr147)
+  %175 = bitcast %"int[]"* %result148 to { i8*, i64 }*
+  store { i8*, i64 } %174, { i8*, i64 }* %175, align 8
+  %176 = bitcast %"int[]"* %result148 to i8*
+  %177 = insertvalue %variant undef, i8* %176, 0
+  %178 = insertvalue %variant %177, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
+  %179 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots136, i64 0, i64 0
+  store %variant %178, %variant* %179, align 16
+  %180 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg135, i32 0, i32 1
+  store i64 1, i64* %180, align 8
+  %181 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg135, i32 0, i32 0
+  %182 = bitcast [1 x %variant]* %varargslots136 to %variant*
+  store %variant* %182, %variant** %181, align 8
+  %183 = bitcast %"variant[]"* %vararg135 to { i8*, i64 }*
+  %184 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %183, i32 0, i32 0
+  %lo149 = load i8*, i8** %184, align 8
+  %185 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %183, i32 0, i32 1
+  %hi150 = load i64, i64* %185, align 8
+  %186 = call i64 @std_io_printfln(i64* %retparam131, i8* %lo133, i64 %hi134, i8* %lo149, i64 %hi150)
+  %not_err151 = icmp eq i64 %186, 0
+  br i1 %not_err151, label %after_check152, label %voiderr153
+
+after_check152:                                   ; preds = %if.exit146
+  br label %voiderr153
+
+voiderr153:                                       ; preds = %after_check152, %if.exit146
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.24, i32 0, i32 0), i64 2 }, %"char[]"* %taddr155, align 8
+  %187 = bitcast %"char[]"* %taddr155 to { i8*, i64 }*
+  %188 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %187, i32 0, i32 0
+  %lo156 = load i8*, i8** %188, align 8
+  %189 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %187, i32 0, i32 1
+  %hi157 = load i64, i64* %189, align 8
+  %190 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not160 = icmp eq %TempAllocator* %190, null
+  br i1 %not160, label %if.then161, label %if.exit169
+
+if.then161:                                       ; preds = %voiderr153
+  %191 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam163, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err164 = icmp eq i64 %191, 0
+  br i1 %not_err164, label %after_check166, label %assign_optional165
+
+assign_optional165:                               ; preds = %if.then161
+  store i64 %191, i64* %error_var162, align 8
+  br label %panic_block167
+
+after_check166:                                   ; preds = %if.then161
+  %192 = load %TempAllocator*, %TempAllocator** %retparam163, align 8
+  br label %noerr_block168
+
+panic_block167:                                   ; preds = %assign_optional165
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.25, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.26, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.27, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block168:                                   ; preds = %after_check166
+  store %TempAllocator* %192, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit169
+
+if.exit169:                                       ; preds = %noerr_block168, %voiderr153
+  %193 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr170 = bitcast %TempAllocator* %193 to %Allocator*
+  %194 = call { i8*, i64 } @"std_map$$int.double_HashMap_value_list"(%HashMap.3* %map2, %Allocator* %ptrptr170)
+  %195 = bitcast %"double[]"* %result171 to { i8*, i64 }*
+  store { i8*, i64 } %194, { i8*, i64 }* %195, align 8
+  %196 = bitcast %"double[]"* %result171 to i8*
+  %197 = insertvalue %variant undef, i8* %196, 0
+  %198 = insertvalue %variant %197, i64 ptrtoint (%.introspect* @"ct$sa$double" to i64), 1
+  %199 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots159, i64 0, i64 0
+  store %variant %198, %variant* %199, align 16
+  %200 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg158, i32 0, i32 1
+  store i64 1, i64* %200, align 8
+  %201 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg158, i32 0, i32 0
+  %202 = bitcast [1 x %variant]* %varargslots159 to %variant*
+  store %variant* %202, %variant** %201, align 8
+  %203 = bitcast %"variant[]"* %vararg158 to { i8*, i64 }*
   %204 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %203, i32 0, i32 0
-  %lo145 = load i8*, i8** %204, align 8
+  %lo172 = load i8*, i8** %204, align 8
   %205 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %203, i32 0, i32 1
-  %hi146 = load i64, i64* %205, align 8
-  %206 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_tlist"(%HashMap.3* %map3)
-  %207 = bitcast %"int[]"* %result149 to { i8*, i64 }*
-  store { i8*, i64 } %206, { i8*, i64 }* %207, align 8
-  %208 = bitcast %"int[]"* %result149 to i8*
-  %209 = insertvalue %variant undef, i8* %208, 0
-  %210 = insertvalue %variant %209, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
-  %211 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots148, i64 0, i64 0
-  store %variant %210, %variant* %211, align 16
-  %212 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg147, i32 0, i32 1
-  store i64 1, i64* %212, align 8
-  %213 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg147, i32 0, i32 0
-  %214 = bitcast [1 x %variant]* %varargslots148 to %variant*
-  store %variant* %214, %variant** %213, align 8
-  %215 = bitcast %"variant[]"* %vararg147 to { i8*, i64 }*
-  %216 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %215, i32 0, i32 0
-  %lo150 = load i8*, i8** %216, align 8
-  %217 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %215, i32 0, i32 1
-  %hi151 = load i64, i64* %217, align 8
-  %218 = call i64 @std_io_printfln(i64* %retparam143, i8* %lo145, i64 %hi146, i8* %lo150, i64 %hi151)
-  %not_err152 = icmp eq i64 %218, 0
-  br i1 %not_err152, label %after_check153, label %voiderr154
+  %hi173 = load i64, i64* %205, align 8
+  %206 = call i64 @std_io_printfln(i64* %retparam154, i8* %lo156, i64 %hi157, i8* %lo172, i64 %hi173)
+  %not_err174 = icmp eq i64 %206, 0
+  br i1 %not_err174, label %after_check175, label %voiderr176
 
-after_check153:                                   ; preds = %if.exit142
-  br label %voiderr154
+after_check175:                                   ; preds = %if.exit169
+  br label %voiderr176
 
-voiderr154:                                       ; preds = %after_check153, %if.exit142
-  %219 = load %TempAllocator*, %TempAllocator** %temp, align 8
-  %220 = getelementptr inbounds %TempAllocator, %TempAllocator* %219, i32 0, i32 0
-  %221 = load i64, i64* %mark, align 8
-  call void @std_core_mem_allocator_Allocator_reset(%Allocator* %220, i64 %221)
+voiderr176:                                       ; preds = %after_check175, %if.exit169
+  %207 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not177 = icmp eq %TempAllocator* %207, null
+  br i1 %not177, label %if.then178, label %if.exit186
+
+if.then178:                                       ; preds = %voiderr176
+  %208 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam180, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err181 = icmp eq i64 %208, 0
+  br i1 %not_err181, label %after_check183, label %assign_optional182
+
+assign_optional182:                               ; preds = %if.then178
+  store i64 %208, i64* %error_var179, align 8
+  br label %panic_block184
+
+after_check183:                                   ; preds = %if.then178
+  %209 = load %TempAllocator*, %TempAllocator** %retparam180, align 8
+  br label %noerr_block185
+
+panic_block184:                                   ; preds = %assign_optional182
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.28, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.29, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.30, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block185:                                   ; preds = %after_check183
+  store %TempAllocator* %209, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit186
+
+if.exit186:                                       ; preds = %noerr_block185, %voiderr176
+  %210 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  store %TempAllocator* %210, %TempAllocator** %temp, align 8
+  %211 = load %TempAllocator*, %TempAllocator** %temp, align 8
+  %212 = getelementptr inbounds %TempAllocator, %TempAllocator* %211, i32 0, i32 3
+  %213 = load i64, i64* %212, align 8
+  store i64 %213, i64* %mark, align 8
+  %214 = bitcast %HashMap.3* %map3 to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 8 %214, i8 0, i64 40, i1 false)
+  %215 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not187 = icmp eq %TempAllocator* %215, null
+  br i1 %not187, label %if.then188, label %if.exit196
+
+if.then188:                                       ; preds = %if.exit186
+  %216 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam190, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err191 = icmp eq i64 %216, 0
+  br i1 %not_err191, label %after_check193, label %assign_optional192
+
+assign_optional192:                               ; preds = %if.then188
+  store i64 %216, i64* %error_var189, align 8
+  br label %panic_block194
+
+after_check193:                                   ; preds = %if.then188
+  %217 = load %TempAllocator*, %TempAllocator** %retparam190, align 8
+  br label %noerr_block195
+
+panic_block194:                                   ; preds = %assign_optional192
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.31, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.32, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.33, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block195:                                   ; preds = %after_check193
+  store %TempAllocator* %217, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit196
+
+if.exit196:                                       ; preds = %noerr_block195, %if.exit186
+  %218 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr197 = bitcast %TempAllocator* %218 to %Allocator*
+  call void @"std_map$$int.double_HashMap_init"(%HashMap.3* %map3, i32 16, float 7.500000e-01, %Allocator* %ptrptr197)
+  %219 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 5, double 3.200000e+00)
+  %220 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 7, double 5.200000e+00)
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i32 0, i32 0), i64 2 }, %"char[]"* %taddr199, align 8
+  %221 = bitcast %"char[]"* %taddr199 to { i8*, i64 }*
+  %222 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %221, i32 0, i32 0
+  %lo200 = load i8*, i8** %222, align 8
+  %223 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %221, i32 0, i32 1
+  %hi201 = load i64, i64* %223, align 8
+  %224 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %not204 = icmp eq %TempAllocator* %224, null
+  br i1 %not204, label %if.then205, label %if.exit213
+
+if.then205:                                       ; preds = %if.exit196
+  %225 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam207, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err208 = icmp eq i64 %225, 0
+  br i1 %not_err208, label %after_check210, label %assign_optional209
+
+assign_optional209:                               ; preds = %if.then205
+  store i64 %225, i64* %error_var206, align 8
+  br label %panic_block211
+
+after_check210:                                   ; preds = %if.then205
+  %226 = load %TempAllocator*, %TempAllocator** %retparam207, align 8
+  br label %noerr_block212
+
+panic_block211:                                   ; preds = %assign_optional209
+  call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.35, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.36, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.37, i64 0, i64 0), i32 250)
+  unreachable
+
+noerr_block212:                                   ; preds = %after_check210
+  store %TempAllocator* %226, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit213
+
+if.exit213:                                       ; preds = %noerr_block212, %if.exit196
+  %227 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
+  %ptrptr214 = bitcast %TempAllocator* %227 to %Allocator*
+  %228 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map3, %Allocator* %ptrptr214)
+  %229 = bitcast %"int[]"* %result215 to { i8*, i64 }*
+  store { i8*, i64 } %228, { i8*, i64 }* %229, align 8
+  %230 = bitcast %"int[]"* %result215 to i8*
+  %231 = insertvalue %variant undef, i8* %230, 0
+  %232 = insertvalue %variant %231, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
+  %233 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots203, i64 0, i64 0
+  store %variant %232, %variant* %233, align 16
+  %234 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg202, i32 0, i32 1
+  store i64 1, i64* %234, align 8
+  %235 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg202, i32 0, i32 0
+  %236 = bitcast [1 x %variant]* %varargslots203 to %variant*
+  store %variant* %236, %variant** %235, align 8
+  %237 = bitcast %"variant[]"* %vararg202 to { i8*, i64 }*
+  %238 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %237, i32 0, i32 0
+  %lo216 = load i8*, i8** %238, align 8
+  %239 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %237, i32 0, i32 1
+  %hi217 = load i64, i64* %239, align 8
+  %240 = call i64 @std_io_printfln(i64* %retparam198, i8* %lo200, i64 %hi201, i8* %lo216, i64 %hi217)
+  %not_err218 = icmp eq i64 %240, 0
+  br i1 %not_err218, label %after_check219, label %voiderr220
+
+after_check219:                                   ; preds = %if.exit213
+  br label %voiderr220
+
+voiderr220:                                       ; preds = %after_check219, %if.exit213
+  %241 = load %TempAllocator*, %TempAllocator** %temp, align 8
+  %242 = getelementptr inbounds %TempAllocator, %TempAllocator* %241, i32 0, i32 0
+  %243 = load i64, i64* %mark, align 8
+  call void @std_core_mem_allocator_Allocator_reset(%Allocator* %242, i64 %243)
   ret void
 }
diff --git a/test/test_suite2/compile_time/ct_funcptr.c3t b/test/test_suite2/compile_time/ct_funcptr.c3t
new file mode 100644
index 000000000..82166656e
--- /dev/null
+++ b/test/test_suite2/compile_time/ct_funcptr.c3t
@@ -0,0 +1,65 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void test(int x)
+{
+	$typeof($$FUNCPTR) ptr = $$FUNCPTR;
+	io::printfln("%d", x);
+	if (x > 0) ptr(x - 1);
+}
+
+fn void main()
+{
+	test(10);
+}
+
+/* #expect: test.ll
+
+define void @test_test(i32 %0) #0 {
+entry:
+  %ptr = alloca ptr, align 8
+  %retparam = alloca i64, align 8
+  %taddr = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [1 x %variant], align 16
+  %taddr1 = alloca i32, align 4
+  store ptr @test_test, ptr %ptr, align 8
+  store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8
+  %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %lo = load ptr, ptr %1, align 8
+  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %hi = load i64, ptr %2, align 8
+  store i32 %0, ptr %taddr1, align 4
+  %3 = insertvalue %variant undef, ptr %taddr1, 0
+  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  store %variant %4, ptr %5, align 16
+  %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  store i64 1, ptr %6, align 8
+  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  store ptr %varargslots, ptr %7, align 8
+  %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %lo2 = load ptr, ptr %8, align 8
+  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %hi3 = load i64, ptr %9, align 8
+  %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3)
+  %not_err = icmp eq i64 %10, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %entry
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %entry
+  %gt = icmp sgt i32 %0, 0
+  br i1 %gt, label %if.then, label %if.exit
+
+if.then:                                          ; preds = %voiderr
+  %11 = load ptr, ptr %ptr, align 8
+  %sub = sub i32 %0, 1
+  call void %11(i32 %sub)
+  br label %if.exit
+
+if.exit:                                          ; preds = %if.then, %voiderr
+  ret void
+}
diff --git a/test/test_suite2/compile_time_introspection/nameof_err.c3 b/test/test_suite2/compile_time_introspection/nameof_err.c3
index bcfacfaef..764f6d41b 100644
--- a/test/test_suite2/compile_time_introspection/nameof_err.c3
+++ b/test/test_suite2/compile_time_introspection/nameof_err.c3
@@ -16,5 +16,5 @@ fn void main3()
 
 fn void main4()
 {
-    $extnameof($evaltype("foo::int")); // #error: Built in types cannot have a path prefix.
+    $extnameof($evaltype("foo::int")); // #error: Only valid types may be resolved with $evaltype.
 }
diff --git a/test/test_suite2/compile_time_introspection/sizeof_errors.c3 b/test/test_suite2/compile_time_introspection/sizeof_errors.c3
index 300493acb..1496dc056 100644
--- a/test/test_suite2/compile_time_introspection/sizeof_errors.c3
+++ b/test/test_suite2/compile_time_introspection/sizeof_errors.c3
@@ -1,6 +1,5 @@
 module foo;
 import bar;
-import bar::abc;
 
 fn void a()
 {
@@ -25,7 +24,7 @@ fn void f()
 
 fn void g()
 {
-    int x = $evaltype("bar::").sizeof; // #error: A valid name was expected here.
+    int x = $evaltype("bar::").sizeof; // #error: Only valid types may be resolved with $evaltype
 }
 
 fn void k()
diff --git a/test/test_suite2/overloading/set_overload.c3t b/test/test_suite2/overloading/set_overload.c3t
new file mode 100644
index 000000000..9d121162f
--- /dev/null
+++ b/test/test_suite2/overloading/set_overload.c3t
@@ -0,0 +1,36 @@
+// #target: macos-x64
+
+module test;
+import std::map;
+
+define IntMap = HashMap<char[], int>;
+
+fn void main()
+{
+	IntMap map;
+	map.set("Hello", 4);
+	map["Bye"] = 5;
+}
+
+/* #expect: test.ll
+
+define void @test_main() #0 {
+entry:
+  %map = alloca %HashMap, align 8
+  %taddr = alloca %"char[]", align 8
+  %taddr1 = alloca %"char[]", align 8
+  call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
+  store %"char[]" { ptr @.str, i64 5 }, ptr %taddr, align 8
+  %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %lo = load ptr, ptr %0, align 8
+  %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %hi = load i64, ptr %1, align 8
+  %2 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr %lo, i64 %hi, i32 4)
+  store %"char[]" { ptr @.str.1, i64 3 }, ptr %taddr1, align 8
+  %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0
+  %lo2 = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1
+  %hi3 = load i64, ptr %4, align 8
+  %5 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr %lo2, i64 %hi3, i32 5)
+  ret void
+}
\ No newline at end of file
diff --git a/test/test_suite2/stdlib/map.c3t b/test/test_suite2/stdlib/map.c3t
index 5e16d565a..1d3d9f413 100644
--- a/test/test_suite2/stdlib/map.c3t
+++ b/test/test_suite2/stdlib/map.c3t
@@ -46,10 +46,10 @@ fn void main()
 	@pool()
 	{
 		IntDoubleMap map3;
-		map3.init(.allocator = mem::temp_allocator());
+		map3.init();
 		map3.set(5, 3.2);
 		map3.set(7, 5.2);
-		io::printfln("%s", map3.key_tlist());
+		io::printfln("%s", map3.key_list());
 	};
 }
 
@@ -58,17 +58,45 @@ fn void main()
 
 define internal void @.static_initialize.0() {
 entry:
+  %error_var = alloca i64, align 8
+  %retparam = alloca ptr, align 8
   %0 = load i64, ptr getelementptr inbounds (%"Entry*[]", ptr @std_io_tostring_functions, i32 0, i32 1), align 8
   %not = icmp eq i64 %0, 0
-  br i1 %not, label %if.then, label %if.exit
+  br i1 %not, label %if.then, label %if.exit3
 
 if.then:                                          ; preds = %entry
-  %1 = load ptr, ptr @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(ptr @std_io_tostring_functions, i32 512, float 7.500000e-01, ptr %1)
+  %1 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not1 = icmp eq ptr %1, null
+  br i1 %not1, label %if.then2, label %if.exit
+
+if.then2:                                         ; preds = %if.then
+  %2 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err = icmp eq i64 %2, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then2
+  store i64 %2, ptr %error_var, align 8
+  br label %panic_block
+
+after_check:                                      ; preds = %if.then2
+  %3 = load ptr, ptr %retparam, align 8
+  br label %noerr_block
+
+panic_block:                                      ; preds = %assign_optional
+  call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.1, ptr @.zstr.2, i32 250)
+  unreachable
+
+noerr_block:                                      ; preds = %after_check
+  store ptr %3, ptr @std_core_mem_thread_temp_allocator, align 8
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %entry
-  %2 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(ptr @std_io_tostring_functions, i64 ptrtoint (ptr @"ct$test_Foo" to i64), ptr @test_Foo_to_string)
+if.exit:                                          ; preds = %noerr_block, %if.then
+  %4 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(ptr @std_io_tostring_functions, i32 512, float 7.500000e-01, ptr %4)
+  br label %if.exit3
+
+if.exit3:                                         ; preds = %if.exit, %entry
+  %5 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(ptr @std_io_tostring_functions, i64 ptrtoint (ptr @"ct$test_Foo" to i64), ptr @test_Foo_to_string)
   ret void
 }
 
@@ -83,7 +111,7 @@ entry:
   %tempcoerce = alloca { ptr, i64 }, align 8
   %2 = call ptr @std_core_string_new_with_capacity(i64 128, ptr %1)
   store ptr %2, ptr %s, align 8
-  store %"char[]" { ptr @.str.17, i64 8 }, ptr %taddr, align 8
+  store %"char[]" { ptr @.str.38, i64 8 }, ptr %taddr, align 8
   %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
   %lo = load ptr, ptr %3, align 8
   %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
@@ -126,500 +154,672 @@ voiderr:                                          ; preds = %after_check, %entry
 define void @test_main() #0 {
 entry:
   %map = alloca %HashMap.0, align 8
-  %retparam = alloca i64, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca ptr, align 8
+  %retparam1 = alloca i64, align 8
   %taddr = alloca %"char[]", align 8
   %vararg = alloca %"variant[]", align 8
   %varargslots = alloca [1 x %variant], align 16
   %literal = alloca %Foo, align 8
-  %retparam5 = alloca i64, align 8
-  %taddr6 = alloca %"char[]", align 8
-  %vararg9 = alloca %"variant[]", align 8
-  %varargslots10 = alloca [1 x %variant], align 16
-  %literal16 = alloca %Foo, align 8
-  %retparam19 = alloca i64, align 8
-  %taddr20 = alloca %"char[]", align 8
-  %vararg23 = alloca %"variant[]", align 8
-  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam30 = alloca i64, align 8
-  %taddr31 = alloca %"char[]", align 8
-  %vararg34 = alloca %"variant[]", align 8
-  %varargslots35 = alloca [1 x %variant], align 16
-  %retparam36 = alloca %Foo, align 8
-  %retparam44 = alloca i64, align 8
-  %taddr45 = alloca %"char[]", align 8
-  %vararg48 = alloca %"variant[]", align 8
-  %varargslots49 = alloca [1 x %variant], align 16
-  %taddr50 = alloca i8, align 1
-  %retparam56 = alloca i64, align 8
-  %taddr57 = alloca %"char[]", align 8
-  %vararg60 = alloca %"variant[]", align 8
-  %varargslots61 = alloca [1 x %variant], align 16
-  %taddr62 = alloca i8, align 1
-  %literal68 = alloca %Foo, align 8
-  %retparam71 = alloca i64, align 8
-  %taddr72 = alloca %"char[]", align 8
-  %vararg75 = alloca %"variant[]", align 8
-  %varargslots76 = alloca [1 x %variant], align 16
+  %retparam8 = alloca i64, align 8
+  %taddr9 = alloca %"char[]", align 8
+  %vararg12 = alloca %"variant[]", align 8
+  %varargslots13 = alloca [1 x %variant], align 16
+  %literal19 = alloca %Foo, align 8
+  %retparam22 = alloca i64, align 8
+  %taddr23 = alloca %"char[]", align 8
+  %vararg26 = alloca %"variant[]", align 8
+  %varargslots27 = alloca [1 x %variant], align 16
+  %retparam33 = alloca i64, align 8
+  %taddr34 = alloca %"char[]", align 8
+  %vararg37 = alloca %"variant[]", align 8
+  %varargslots38 = alloca [1 x %variant], align 16
+  %retparam39 = alloca %Foo, align 8
+  %retparam47 = alloca i64, align 8
+  %taddr48 = alloca %"char[]", align 8
+  %vararg51 = alloca %"variant[]", align 8
+  %varargslots52 = alloca [1 x %variant], align 16
+  %taddr53 = alloca i8, align 1
+  %retparam59 = alloca i64, align 8
+  %taddr60 = alloca %"char[]", align 8
+  %vararg63 = alloca %"variant[]", align 8
+  %varargslots64 = alloca [1 x %variant], align 16
+  %taddr65 = alloca i8, align 1
+  %literal71 = alloca %Foo, align 8
+  %retparam74 = alloca i64, align 8
+  %taddr75 = alloca %"char[]", align 8
+  %vararg78 = alloca %"variant[]", align 8
+  %varargslots79 = alloca [1 x %variant], align 16
+  %error_var82 = alloca i64, align 8
+  %retparam83 = alloca ptr, align 8
   %result = alloca %"Foo[]", align 8
   %map2 = alloca %HashMap.3, align 8
-  %retparam82 = alloca i64, align 8
-  %taddr83 = alloca %"char[]", align 8
-  %vararg86 = alloca %"variant[]", align 8
-  %varargslots87 = alloca [1 x %variant], align 16
-  %taddr88 = alloca i8, align 1
-  %retparam94 = alloca i64, align 8
-  %taddr95 = alloca %"char[]", align 8
-  %vararg98 = alloca %"variant[]", align 8
-  %varargslots99 = alloca [1 x %variant], align 16
-  %taddr100 = alloca i8, align 1
-  %retparam106 = alloca i64, align 8
-  %taddr107 = alloca %"char[]", align 8
-  %vararg110 = alloca %"variant[]", align 8
-  %varargslots111 = alloca [1 x %variant], align 16
-  %result112 = alloca %"int[]", align 8
-  %retparam118 = alloca i64, align 8
-  %taddr119 = alloca %"char[]", align 8
-  %vararg122 = alloca %"variant[]", align 8
-  %varargslots123 = alloca [1 x %variant], align 16
-  %result124 = alloca %"double[]", align 8
+  %error_var97 = alloca i64, align 8
+  %retparam98 = alloca ptr, align 8
+  %retparam105 = alloca i64, align 8
+  %taddr106 = alloca %"char[]", align 8
+  %vararg109 = alloca %"variant[]", align 8
+  %varargslots110 = alloca [1 x %variant], align 16
+  %taddr111 = alloca i8, align 1
+  %retparam117 = alloca i64, align 8
+  %taddr118 = alloca %"char[]", align 8
+  %vararg121 = alloca %"variant[]", align 8
+  %varargslots122 = alloca [1 x %variant], align 16
+  %taddr123 = alloca i8, align 1
+  %retparam129 = alloca i64, align 8
+  %taddr130 = alloca %"char[]", align 8
+  %vararg133 = alloca %"variant[]", align 8
+  %varargslots134 = alloca [1 x %variant], align 16
+  %error_var137 = alloca i64, align 8
+  %retparam138 = alloca ptr, align 8
+  %result145 = alloca %"int[]", align 8
+  %retparam151 = alloca i64, align 8
+  %taddr152 = alloca %"char[]", align 8
+  %vararg155 = alloca %"variant[]", align 8
+  %varargslots156 = alloca [1 x %variant], align 16
+  %error_var159 = alloca i64, align 8
+  %retparam160 = alloca ptr, align 8
+  %result167 = alloca %"double[]", align 8
   %temp = alloca ptr, align 8
-  %error_var = alloca i64, align 8
-  %retparam130 = alloca ptr, align 8
+  %error_var175 = alloca i64, align 8
+  %retparam176 = alloca ptr, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.3, align 8
-  %error_var135 = alloca i64, align 8
-  %retparam136 = alloca ptr, align 8
-  %retparam143 = alloca i64, align 8
-  %taddr144 = alloca %"char[]", align 8
-  %vararg147 = alloca %"variant[]", align 8
-  %varargslots148 = alloca [1 x %variant], align 16
-  %result149 = alloca %"int[]", align 8
+  %error_var185 = alloca i64, align 8
+  %retparam186 = alloca ptr, align 8
+  %retparam193 = alloca i64, align 8
+  %taddr194 = alloca %"char[]", align 8
+  %vararg197 = alloca %"variant[]", align 8
+  %varargslots198 = alloca [1 x %variant], align 16
+  %error_var201 = alloca i64, align 8
+  %retparam202 = alloca ptr, align 8
+  %result209 = alloca %"int[]", align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
-  %0 = load ptr, ptr @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
-  store %"char[]" { ptr @.str, i64 12 }, ptr %taddr, align 8
-  %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
-  %lo = load ptr, ptr %1, align 8
-  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
-  %hi = load i64, ptr %2, align 8
-  %3 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
-  %4 = insertvalue %variant undef, ptr %3, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %5, ptr %6, align 16
-  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
-  store i64 1, ptr %7, align 8
-  %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
-  store ptr %varargslots, ptr %8, align 8
-  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
-  %lo1 = load ptr, ptr %9, align 8
-  %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
-  %hi2 = load i64, ptr %10, align 8
-  %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
-  %not_err = icmp eq i64 %11, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
-  %12 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
-  store i32 1, ptr %12, align 8
-  %13 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
-  store ptr null, ptr %13, align 8
-  %14 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0
-  %lo3 = load i64, ptr %14, align 8
-  %15 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1
-  %hi4 = load ptr, ptr %15, align 8
-  %16 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo3, ptr %hi4)
-  store %"char[]" { ptr @.str.1, i64 12 }, ptr %taddr6, align 8
-  %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0
-  %lo7 = load ptr, ptr %17, align 8
-  %18 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1
-  %hi8 = load i64, ptr %18, align 8
-  %19 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
-  %20 = insertvalue %variant undef, ptr %19, 0
-  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %22 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
-  store %variant %21, ptr %22, align 16
-  %23 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1
-  store i64 1, ptr %23, align 8
-  %24 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0
-  store ptr %varargslots10, ptr %24, align 8
-  %25 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0
-  %lo11 = load ptr, ptr %25, align 8
-  %26 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1
-  %hi12 = load i64, ptr %26, align 8
-  %27 = call i64 @std_io_printfln(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12)
-  %not_err13 = icmp eq i64 %27, 0
-  br i1 %not_err13, label %after_check14, label %voiderr15
-
-after_check14:                                    ; preds = %voiderr
-  br label %voiderr15
-
-voiderr15:                                        ; preds = %after_check14, %voiderr
-  %28 = getelementptr inbounds %Foo, ptr %literal16, i32 0, i32 0
-  store i32 2, ptr %28, align 8
-  %29 = getelementptr inbounds %Foo, ptr %literal16, i32 0, i32 1
-  store ptr null, ptr %29, align 8
-  %30 = getelementptr inbounds { i64, ptr }, ptr %literal16, i32 0, i32 0
-  %lo17 = load i64, ptr %30, align 8
-  %31 = getelementptr inbounds { i64, ptr }, ptr %literal16, i32 0, i32 1
-  %hi18 = load ptr, ptr %31, align 8
-  %32 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo17, ptr %hi18)
-  store %"char[]" { ptr @.str.2, i64 12 }, ptr %taddr20, align 8
-  %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0
-  %lo21 = load ptr, ptr %33, align 8
-  %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1
-  %hi22 = load i64, ptr %34, align 8
-  %35 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
-  %36 = insertvalue %variant undef, ptr %35, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %38 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
-  store %variant %37, ptr %38, align 16
-  %39 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1
-  store i64 1, ptr %39, align 8
-  %40 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0
-  store ptr %varargslots24, ptr %40, align 8
-  %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0
-  %lo25 = load ptr, ptr %41, align 8
-  %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1
-  %hi26 = load i64, ptr %42, align 8
-  %43 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26)
-  %not_err27 = icmp eq i64 %43, 0
-  br i1 %not_err27, label %after_check28, label %voiderr29
-
-after_check28:                                    ; preds = %voiderr15
-  br label %voiderr29
-
-voiderr29:                                        ; preds = %after_check28, %voiderr15
-  store %"char[]" { ptr @.str.3, i64 7 }, ptr %taddr31, align 8
-  %44 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 0
-  %lo32 = load ptr, ptr %44, align 8
-  %45 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 1
-  %hi33 = load i64, ptr %45, align 8
-  %46 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam36, ptr %map, i32 1)
-  %not_err37 = icmp eq i64 %46, 0
-  br i1 %not_err37, label %after_check38, label %voiderr43
-
-after_check38:                                    ; preds = %voiderr29
-  %47 = getelementptr inbounds %Foo, ptr %retparam36, i32 0, i32 0
-  %48 = insertvalue %variant undef, ptr %47, 0
-  %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %50 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
-  store %variant %49, ptr %50, align 16
-  %51 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 1
-  store i64 1, ptr %51, align 8
-  %52 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 0
-  store ptr %varargslots35, ptr %52, align 8
-  %53 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 0
-  %lo39 = load ptr, ptr %53, align 8
-  %54 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 1
-  %hi40 = load i64, ptr %54, align 8
-  %55 = call i64 @std_io_printfln(ptr %retparam30, ptr %lo32, i64 %hi33, ptr %lo39, i64 %hi40)
-  %not_err41 = icmp eq i64 %55, 0
-  br i1 %not_err41, label %after_check42, label %voiderr43
-
-after_check42:                                    ; preds = %after_check38
-  br label %voiderr43
-
-voiderr43:                                        ; preds = %after_check42, %after_check38, %voiderr29
-  store %"char[]" { ptr @.str.4, i64 9 }, ptr %taddr45, align 8
-  %56 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 0
-  %lo46 = load ptr, ptr %56, align 8
-  %57 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 1
-  %hi47 = load i64, ptr %57, align 8
-  %58 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1)
-  store i8 %58, ptr %taddr50, align 1
-  %59 = insertvalue %variant undef, ptr %taddr50, 0
-  %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %61 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0
-  store %variant %60, ptr %61, align 16
-  %62 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 1
-  store i64 1, ptr %62, align 8
-  %63 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 0
-  store ptr %varargslots49, ptr %63, align 8
-  %64 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 0
-  %lo51 = load ptr, ptr %64, align 8
-  %65 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 1
-  %hi52 = load i64, ptr %65, align 8
-  %66 = call i64 @std_io_printfln(ptr %retparam44, ptr %lo46, i64 %hi47, ptr %lo51, i64 %hi52)
-  %not_err53 = icmp eq i64 %66, 0
-  br i1 %not_err53, label %after_check54, label %voiderr55
-
-after_check54:                                    ; preds = %voiderr43
-  br label %voiderr55
-
-voiderr55:                                        ; preds = %after_check54, %voiderr43
-  store %"char[]" { ptr @.str.5, i64 9 }, ptr %taddr57, align 8
-  %67 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 0
-  %lo58 = load ptr, ptr %67, align 8
-  %68 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 1
-  %hi59 = load i64, ptr %68, align 8
-  %69 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2)
-  store i8 %69, ptr %taddr62, align 1
-  %70 = insertvalue %variant undef, ptr %taddr62, 0
-  %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %72 = getelementptr inbounds [1 x %variant], ptr %varargslots61, i64 0, i64 0
-  store %variant %71, ptr %72, align 16
-  %73 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 1
-  store i64 1, ptr %73, align 8
-  %74 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 0
-  store ptr %varargslots61, ptr %74, align 8
-  %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 0
-  %lo63 = load ptr, ptr %75, align 8
-  %76 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 1
-  %hi64 = load i64, ptr %76, align 8
-  %77 = call i64 @std_io_printfln(ptr %retparam56, ptr %lo58, i64 %hi59, ptr %lo63, i64 %hi64)
-  %not_err65 = icmp eq i64 %77, 0
-  br i1 %not_err65, label %after_check66, label %voiderr67
-
-after_check66:                                    ; preds = %voiderr55
-  br label %voiderr67
-
-voiderr67:                                        ; preds = %after_check66, %voiderr55
-  %78 = getelementptr inbounds %Foo, ptr %literal68, i32 0, i32 0
-  store i32 4, ptr %78, align 8
-  %79 = getelementptr inbounds %Foo, ptr %literal68, i32 0, i32 1
-  store ptr null, ptr %79, align 8
-  %80 = getelementptr inbounds { i64, ptr }, ptr %literal68, i32 0, i32 0
-  %lo69 = load i64, ptr %80, align 8
-  %81 = getelementptr inbounds { i64, ptr }, ptr %literal68, i32 0, i32 1
-  %hi70 = load ptr, ptr %81, align 8
-  %82 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo69, ptr %hi70)
-  store %"char[]" { ptr @.str.6, i64 10 }, ptr %taddr72, align 8
-  %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr72, i32 0, i32 0
-  %lo73 = load ptr, ptr %83, align 8
-  %84 = getelementptr inbounds { ptr, i64 }, ptr %taddr72, i32 0, i32 1
-  %hi74 = load i64, ptr %84, align 8
-  %85 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr null)
-  store { ptr, i64 } %85, ptr %result, align 8
-  %86 = insertvalue %variant undef, ptr %result, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1
-  %88 = getelementptr inbounds [1 x %variant], ptr %varargslots76, i64 0, i64 0
-  store %variant %87, ptr %88, align 16
-  %89 = getelementptr inbounds %"variant[]", ptr %vararg75, i32 0, i32 1
-  store i64 1, ptr %89, align 8
-  %90 = getelementptr inbounds %"variant[]", ptr %vararg75, i32 0, i32 0
-  store ptr %varargslots76, ptr %90, align 8
-  %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg75, i32 0, i32 0
-  %lo77 = load ptr, ptr %91, align 8
-  %92 = getelementptr inbounds { ptr, i64 }, ptr %vararg75, i32 0, i32 1
-  %hi78 = load i64, ptr %92, align 8
-  %93 = call i64 @std_io_printfln(ptr %retparam71, ptr %lo73, i64 %hi74, ptr %lo77, i64 %hi78)
-  %not_err79 = icmp eq i64 %93, 0
-  br i1 %not_err79, label %after_check80, label %voiderr81
-
-after_check80:                                    ; preds = %voiderr67
-  br label %voiderr81
-
-voiderr81:                                        ; preds = %after_check80, %voiderr67
-  call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
-  %94 = load ptr, ptr @std_core_mem_thread_allocator, align 8
-  call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %94)
-  %95 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00)
-  store %"char[]" { ptr @.str.7, i64 12 }, ptr %taddr83, align 8
-  %96 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 0
-  %lo84 = load ptr, ptr %96, align 8
-  %97 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 1
-  %hi85 = load i64, ptr %97, align 8
-  %98 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00)
-  store i8 %98, ptr %taddr88, align 1
-  %99 = insertvalue %variant undef, ptr %taddr88, 0
-  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %101 = getelementptr inbounds [1 x %variant], ptr %varargslots87, i64 0, i64 0
-  store %variant %100, ptr %101, align 16
-  %102 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 1
-  store i64 1, ptr %102, align 8
-  %103 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 0
-  store ptr %varargslots87, ptr %103, align 8
-  %104 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 0
-  %lo89 = load ptr, ptr %104, align 8
-  %105 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 1
-  %hi90 = load i64, ptr %105, align 8
-  %106 = call i64 @std_io_printfln(ptr %retparam82, ptr %lo84, i64 %hi85, ptr %lo89, i64 %hi90)
-  %not_err91 = icmp eq i64 %106, 0
-  br i1 %not_err91, label %after_check92, label %voiderr93
-
-after_check92:                                    ; preds = %voiderr81
-  br label %voiderr93
-
-voiderr93:                                        ; preds = %after_check92, %voiderr81
-  store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr95, align 8
-  %107 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 0
-  %lo96 = load ptr, ptr %107, align 8
-  %108 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 1
-  %hi97 = load i64, ptr %108, align 8
-  %109 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00)
-  store i8 %109, ptr %taddr100, align 1
-  %110 = insertvalue %variant undef, ptr %taddr100, 0
-  %111 = insertvalue %variant %110, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %112 = getelementptr inbounds [1 x %variant], ptr %varargslots99, i64 0, i64 0
-  store %variant %111, ptr %112, align 16
-  %113 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 1
-  store i64 1, ptr %113, align 8
-  %114 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 0
-  store ptr %varargslots99, ptr %114, align 8
-  %115 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 0
-  %lo101 = load ptr, ptr %115, align 8
-  %116 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 1
-  %hi102 = load i64, ptr %116, align 8
-  %117 = call i64 @std_io_printfln(ptr %retparam94, ptr %lo96, i64 %hi97, ptr %lo101, i64 %hi102)
-  %not_err103 = icmp eq i64 %117, 0
-  br i1 %not_err103, label %after_check104, label %voiderr105
-
-after_check104:                                   ; preds = %voiderr93
-  br label %voiderr105
-
-voiderr105:                                       ; preds = %after_check104, %voiderr93
-  %118 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00)
-  store %"char[]" { ptr @.str.9, i64 2 }, ptr %taddr107, align 8
-  %119 = getelementptr inbounds { ptr, i64 }, ptr %taddr107, i32 0, i32 0
-  %lo108 = load ptr, ptr %119, align 8
-  %120 = getelementptr inbounds { ptr, i64 }, ptr %taddr107, i32 0, i32 1
-  %hi109 = load i64, ptr %120, align 8
-  %121 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr null)
-  store { ptr, i64 } %121, ptr %result112, align 8
-  %122 = insertvalue %variant undef, ptr %result112, 0
-  %123 = insertvalue %variant %122, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
-  %124 = getelementptr inbounds [1 x %variant], ptr %varargslots111, i64 0, i64 0
-  store %variant %123, ptr %124, align 16
-  %125 = getelementptr inbounds %"variant[]", ptr %vararg110, i32 0, i32 1
-  store i64 1, ptr %125, align 8
-  %126 = getelementptr inbounds %"variant[]", ptr %vararg110, i32 0, i32 0
-  store ptr %varargslots111, ptr %126, align 8
-  %127 = getelementptr inbounds { ptr, i64 }, ptr %vararg110, i32 0, i32 0
-  %lo113 = load ptr, ptr %127, align 8
-  %128 = getelementptr inbounds { ptr, i64 }, ptr %vararg110, i32 0, i32 1
-  %hi114 = load i64, ptr %128, align 8
-  %129 = call i64 @std_io_printfln(ptr %retparam106, ptr %lo108, i64 %hi109, ptr %lo113, i64 %hi114)
-  %not_err115 = icmp eq i64 %129, 0
-  br i1 %not_err115, label %after_check116, label %voiderr117
-
-after_check116:                                   ; preds = %voiderr105
-  br label %voiderr117
-
-voiderr117:                                       ; preds = %after_check116, %voiderr105
-  store %"char[]" { ptr @.str.10, i64 2 }, ptr %taddr119, align 8
-  %130 = getelementptr inbounds { ptr, i64 }, ptr %taddr119, i32 0, i32 0
-  %lo120 = load ptr, ptr %130, align 8
-  %131 = getelementptr inbounds { ptr, i64 }, ptr %taddr119, i32 0, i32 1
-  %hi121 = load i64, ptr %131, align 8
-  %132 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr null)
-  store { ptr, i64 } %132, ptr %result124, align 8
-  %133 = insertvalue %variant undef, ptr %result124, 0
-  %134 = insertvalue %variant %133, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1
-  %135 = getelementptr inbounds [1 x %variant], ptr %varargslots123, i64 0, i64 0
-  store %variant %134, ptr %135, align 16
-  %136 = getelementptr inbounds %"variant[]", ptr %vararg122, i32 0, i32 1
-  store i64 1, ptr %136, align 8
-  %137 = getelementptr inbounds %"variant[]", ptr %vararg122, i32 0, i32 0
-  store ptr %varargslots123, ptr %137, align 8
-  %138 = getelementptr inbounds { ptr, i64 }, ptr %vararg122, i32 0, i32 0
-  %lo125 = load ptr, ptr %138, align 8
-  %139 = getelementptr inbounds { ptr, i64 }, ptr %vararg122, i32 0, i32 1
-  %hi126 = load i64, ptr %139, align 8
-  %140 = call i64 @std_io_printfln(ptr %retparam118, ptr %lo120, i64 %hi121, ptr %lo125, i64 %hi126)
-  %not_err127 = icmp eq i64 %140, 0
-  br i1 %not_err127, label %after_check128, label %voiderr129
-
-after_check128:                                   ; preds = %voiderr117
-  br label %voiderr129
-
-voiderr129:                                       ; preds = %after_check128, %voiderr117
-  %141 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
-  %not = icmp eq ptr %141, null
+  %0 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not = icmp eq ptr %0, null
   br i1 %not, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %voiderr129
-  %142 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam130, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
-  %not_err131 = icmp eq i64 %142, 0
-  br i1 %not_err131, label %after_check132, label %assign_optional
+if.then:                                          ; preds = %entry
+  %1 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err = icmp eq i64 %1, 0
+  br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %if.then
-  store i64 %142, ptr %error_var, align 8
+  store i64 %1, ptr %error_var, align 8
   br label %panic_block
 
-after_check132:                                   ; preds = %if.then
-  %143 = load ptr, ptr %retparam130, align 8
+after_check:                                      ; preds = %if.then
+  %2 = load ptr, ptr %retparam, align 8
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
-  call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.11, ptr @.zstr.12, i32 250)
+  call void @std_core_builtin_panic(ptr @.zstr.3, ptr @.zstr.4, ptr @.zstr.5, i32 250)
   unreachable
 
-noerr_block:                                      ; preds = %after_check132
-  store ptr %143, ptr @std_core_mem_thread_temp_allocator, align 8
+noerr_block:                                      ; preds = %after_check
+  store ptr %2, ptr @std_core_mem_thread_temp_allocator, align 8
   br label %if.exit
 
-if.exit:                                          ; preds = %noerr_block, %voiderr129
-  %144 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
-  store ptr %144, ptr %temp, align 8
-  %145 = load ptr, ptr %temp, align 8
-  %146 = getelementptr inbounds %TempAllocator, ptr %145, i32 0, i32 3
-  %147 = load i64, ptr %146, align 8
-  store i64 %147, ptr %mark, align 8
-  call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false)
-  %148 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
-  %not133 = icmp eq ptr %148, null
-  br i1 %not133, label %if.then134, label %if.exit142
+if.exit:                                          ; preds = %noerr_block, %entry
+  %3 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %3)
+  store %"char[]" { ptr @.str, i64 12 }, ptr %taddr, align 8
+  %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %lo = load ptr, ptr %4, align 8
+  %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %hi = load i64, ptr %5, align 8
+  %6 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
+  %7 = insertvalue %variant undef, ptr %6, 0
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %9 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  store %variant %8, ptr %9, align 16
+  %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  store i64 1, ptr %10, align 8
+  %11 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  store ptr %varargslots, ptr %11, align 8
+  %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %lo2 = load ptr, ptr %12, align 8
+  %13 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %hi3 = load i64, ptr %13, align 8
+  %14 = call i64 @std_io_printfln(ptr %retparam1, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3)
+  %not_err4 = icmp eq i64 %14, 0
+  br i1 %not_err4, label %after_check5, label %voiderr
 
-if.then134:                                       ; preds = %if.exit
-  %149 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam136, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
-  %not_err137 = icmp eq i64 %149, 0
-  br i1 %not_err137, label %after_check139, label %assign_optional138
+after_check5:                                     ; preds = %if.exit
+  br label %voiderr
 
-assign_optional138:                               ; preds = %if.then134
-  store i64 %149, ptr %error_var135, align 8
-  br label %panic_block140
+voiderr:                                          ; preds = %after_check5, %if.exit
+  %15 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
+  store i32 1, ptr %15, align 8
+  %16 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
+  store ptr null, ptr %16, align 8
+  %17 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0
+  %lo6 = load i64, ptr %17, align 8
+  %18 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1
+  %hi7 = load ptr, ptr %18, align 8
+  %19 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo6, ptr %hi7)
+  store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr9, align 8
+  %20 = getelementptr inbounds { ptr, i64 }, ptr %taddr9, i32 0, i32 0
+  %lo10 = load ptr, ptr %20, align 8
+  %21 = getelementptr inbounds { ptr, i64 }, ptr %taddr9, i32 0, i32 1
+  %hi11 = load i64, ptr %21, align 8
+  %22 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
+  %23 = insertvalue %variant undef, ptr %22, 0
+  %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %25 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
+  store %variant %24, ptr %25, align 16
+  %26 = getelementptr inbounds %"variant[]", ptr %vararg12, i32 0, i32 1
+  store i64 1, ptr %26, align 8
+  %27 = getelementptr inbounds %"variant[]", ptr %vararg12, i32 0, i32 0
+  store ptr %varargslots13, ptr %27, align 8
+  %28 = getelementptr inbounds { ptr, i64 }, ptr %vararg12, i32 0, i32 0
+  %lo14 = load ptr, ptr %28, align 8
+  %29 = getelementptr inbounds { ptr, i64 }, ptr %vararg12, i32 0, i32 1
+  %hi15 = load i64, ptr %29, align 8
+  %30 = call i64 @std_io_printfln(ptr %retparam8, ptr %lo10, i64 %hi11, ptr %lo14, i64 %hi15)
+  %not_err16 = icmp eq i64 %30, 0
+  br i1 %not_err16, label %after_check17, label %voiderr18
 
-after_check139:                                   ; preds = %if.then134
-  %150 = load ptr, ptr %retparam136, align 8
-  br label %noerr_block141
+after_check17:                                    ; preds = %voiderr
+  br label %voiderr18
 
-panic_block140:                                   ; preds = %assign_optional138
-  call void @std_core_builtin_panic(ptr @.zstr.13, ptr @.zstr.14, ptr @.zstr.15, i32 250)
+voiderr18:                                        ; preds = %after_check17, %voiderr
+  %31 = getelementptr inbounds %Foo, ptr %literal19, i32 0, i32 0
+  store i32 2, ptr %31, align 8
+  %32 = getelementptr inbounds %Foo, ptr %literal19, i32 0, i32 1
+  store ptr null, ptr %32, align 8
+  %33 = getelementptr inbounds { i64, ptr }, ptr %literal19, i32 0, i32 0
+  %lo20 = load i64, ptr %33, align 8
+  %34 = getelementptr inbounds { i64, ptr }, ptr %literal19, i32 0, i32 1
+  %hi21 = load ptr, ptr %34, align 8
+  %35 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo20, ptr %hi21)
+  store %"char[]" { ptr @.str.7, i64 12 }, ptr %taddr23, align 8
+  %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 0
+  %lo24 = load ptr, ptr %36, align 8
+  %37 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 1
+  %hi25 = load i64, ptr %37, align 8
+  %38 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
+  %39 = insertvalue %variant undef, ptr %38, 0
+  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %41 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
+  store %variant %40, ptr %41, align 16
+  %42 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 1
+  store i64 1, ptr %42, align 8
+  %43 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 0
+  store ptr %varargslots27, ptr %43, align 8
+  %44 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 0
+  %lo28 = load ptr, ptr %44, align 8
+  %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 1
+  %hi29 = load i64, ptr %45, align 8
+  %46 = call i64 @std_io_printfln(ptr %retparam22, ptr %lo24, i64 %hi25, ptr %lo28, i64 %hi29)
+  %not_err30 = icmp eq i64 %46, 0
+  br i1 %not_err30, label %after_check31, label %voiderr32
+
+after_check31:                                    ; preds = %voiderr18
+  br label %voiderr32
+
+voiderr32:                                        ; preds = %after_check31, %voiderr18
+  store %"char[]" { ptr @.str.8, i64 7 }, ptr %taddr34, align 8
+  %47 = getelementptr inbounds { ptr, i64 }, ptr %taddr34, i32 0, i32 0
+  %lo35 = load ptr, ptr %47, align 8
+  %48 = getelementptr inbounds { ptr, i64 }, ptr %taddr34, i32 0, i32 1
+  %hi36 = load i64, ptr %48, align 8
+  %49 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam39, ptr %map, i32 1)
+  %not_err40 = icmp eq i64 %49, 0
+  br i1 %not_err40, label %after_check41, label %voiderr46
+
+after_check41:                                    ; preds = %voiderr32
+  %50 = getelementptr inbounds %Foo, ptr %retparam39, i32 0, i32 0
+  %51 = insertvalue %variant undef, ptr %50, 0
+  %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %53 = getelementptr inbounds [1 x %variant], ptr %varargslots38, i64 0, i64 0
+  store %variant %52, ptr %53, align 16
+  %54 = getelementptr inbounds %"variant[]", ptr %vararg37, i32 0, i32 1
+  store i64 1, ptr %54, align 8
+  %55 = getelementptr inbounds %"variant[]", ptr %vararg37, i32 0, i32 0
+  store ptr %varargslots38, ptr %55, align 8
+  %56 = getelementptr inbounds { ptr, i64 }, ptr %vararg37, i32 0, i32 0
+  %lo42 = load ptr, ptr %56, align 8
+  %57 = getelementptr inbounds { ptr, i64 }, ptr %vararg37, i32 0, i32 1
+  %hi43 = load i64, ptr %57, align 8
+  %58 = call i64 @std_io_printfln(ptr %retparam33, ptr %lo35, i64 %hi36, ptr %lo42, i64 %hi43)
+  %not_err44 = icmp eq i64 %58, 0
+  br i1 %not_err44, label %after_check45, label %voiderr46
+
+after_check45:                                    ; preds = %after_check41
+  br label %voiderr46
+
+voiderr46:                                        ; preds = %after_check45, %after_check41, %voiderr32
+  store %"char[]" { ptr @.str.9, i64 9 }, ptr %taddr48, align 8
+  %59 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 0
+  %lo49 = load ptr, ptr %59, align 8
+  %60 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 1
+  %hi50 = load i64, ptr %60, align 8
+  %61 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1)
+  store i8 %61, ptr %taddr53, align 1
+  %62 = insertvalue %variant undef, ptr %taddr53, 0
+  %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %64 = getelementptr inbounds [1 x %variant], ptr %varargslots52, i64 0, i64 0
+  store %variant %63, ptr %64, align 16
+  %65 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 1
+  store i64 1, ptr %65, align 8
+  %66 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 0
+  store ptr %varargslots52, ptr %66, align 8
+  %67 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 0
+  %lo54 = load ptr, ptr %67, align 8
+  %68 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 1
+  %hi55 = load i64, ptr %68, align 8
+  %69 = call i64 @std_io_printfln(ptr %retparam47, ptr %lo49, i64 %hi50, ptr %lo54, i64 %hi55)
+  %not_err56 = icmp eq i64 %69, 0
+  br i1 %not_err56, label %after_check57, label %voiderr58
+
+after_check57:                                    ; preds = %voiderr46
+  br label %voiderr58
+
+voiderr58:                                        ; preds = %after_check57, %voiderr46
+  store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr60, align 8
+  %70 = getelementptr inbounds { ptr, i64 }, ptr %taddr60, i32 0, i32 0
+  %lo61 = load ptr, ptr %70, align 8
+  %71 = getelementptr inbounds { ptr, i64 }, ptr %taddr60, i32 0, i32 1
+  %hi62 = load i64, ptr %71, align 8
+  %72 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2)
+  store i8 %72, ptr %taddr65, align 1
+  %73 = insertvalue %variant undef, ptr %taddr65, 0
+  %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %75 = getelementptr inbounds [1 x %variant], ptr %varargslots64, i64 0, i64 0
+  store %variant %74, ptr %75, align 16
+  %76 = getelementptr inbounds %"variant[]", ptr %vararg63, i32 0, i32 1
+  store i64 1, ptr %76, align 8
+  %77 = getelementptr inbounds %"variant[]", ptr %vararg63, i32 0, i32 0
+  store ptr %varargslots64, ptr %77, align 8
+  %78 = getelementptr inbounds { ptr, i64 }, ptr %vararg63, i32 0, i32 0
+  %lo66 = load ptr, ptr %78, align 8
+  %79 = getelementptr inbounds { ptr, i64 }, ptr %vararg63, i32 0, i32 1
+  %hi67 = load i64, ptr %79, align 8
+  %80 = call i64 @std_io_printfln(ptr %retparam59, ptr %lo61, i64 %hi62, ptr %lo66, i64 %hi67)
+  %not_err68 = icmp eq i64 %80, 0
+  br i1 %not_err68, label %after_check69, label %voiderr70
+
+after_check69:                                    ; preds = %voiderr58
+  br label %voiderr70
+
+voiderr70:                                        ; preds = %after_check69, %voiderr58
+  %81 = getelementptr inbounds %Foo, ptr %literal71, i32 0, i32 0
+  store i32 4, ptr %81, align 8
+  %82 = getelementptr inbounds %Foo, ptr %literal71, i32 0, i32 1
+  store ptr null, ptr %82, align 8
+  %83 = getelementptr inbounds { i64, ptr }, ptr %literal71, i32 0, i32 0
+  %lo72 = load i64, ptr %83, align 8
+  %84 = getelementptr inbounds { i64, ptr }, ptr %literal71, i32 0, i32 1
+  %hi73 = load ptr, ptr %84, align 8
+  %85 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo72, ptr %hi73)
+  store %"char[]" { ptr @.str.11, i64 10 }, ptr %taddr75, align 8
+  %86 = getelementptr inbounds { ptr, i64 }, ptr %taddr75, i32 0, i32 0
+  %lo76 = load ptr, ptr %86, align 8
+  %87 = getelementptr inbounds { ptr, i64 }, ptr %taddr75, i32 0, i32 1
+  %hi77 = load i64, ptr %87, align 8
+  %88 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not80 = icmp eq ptr %88, null
+  br i1 %not80, label %if.then81, label %if.exit89
+
+if.then81:                                        ; preds = %voiderr70
+  %89 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam83, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err84 = icmp eq i64 %89, 0
+  br i1 %not_err84, label %after_check86, label %assign_optional85
+
+assign_optional85:                                ; preds = %if.then81
+  store i64 %89, ptr %error_var82, align 8
+  br label %panic_block87
+
+after_check86:                                    ; preds = %if.then81
+  %90 = load ptr, ptr %retparam83, align 8
+  br label %noerr_block88
+
+panic_block87:                                    ; preds = %assign_optional85
+  call void @std_core_builtin_panic(ptr @.zstr.12, ptr @.zstr.13, ptr @.zstr.14, i32 250)
   unreachable
 
-noerr_block141:                                   ; preds = %after_check139
-  store ptr %150, ptr @std_core_mem_thread_temp_allocator, align 8
-  br label %if.exit142
+noerr_block88:                                    ; preds = %after_check86
+  store ptr %90, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit89
 
-if.exit142:                                       ; preds = %noerr_block141, %if.exit
-  %151 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
-  call void @"std_map$$int.double_HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %151)
-  %152 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 5, double 3.200000e+00)
-  %153 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00)
-  store %"char[]" { ptr @.str.16, i64 2 }, ptr %taddr144, align 8
-  %154 = getelementptr inbounds { ptr, i64 }, ptr %taddr144, i32 0, i32 0
-  %lo145 = load ptr, ptr %154, align 8
-  %155 = getelementptr inbounds { ptr, i64 }, ptr %taddr144, i32 0, i32 1
-  %hi146 = load i64, ptr %155, align 8
-  %156 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_tlist"(ptr %map3)
-  store { ptr, i64 } %156, ptr %result149, align 8
-  %157 = insertvalue %variant undef, ptr %result149, 0
-  %158 = insertvalue %variant %157, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
-  %159 = getelementptr inbounds [1 x %variant], ptr %varargslots148, i64 0, i64 0
-  store %variant %158, ptr %159, align 16
-  %160 = getelementptr inbounds %"variant[]", ptr %vararg147, i32 0, i32 1
-  store i64 1, ptr %160, align 8
-  %161 = getelementptr inbounds %"variant[]", ptr %vararg147, i32 0, i32 0
-  store ptr %varargslots148, ptr %161, align 8
-  %162 = getelementptr inbounds { ptr, i64 }, ptr %vararg147, i32 0, i32 0
-  %lo150 = load ptr, ptr %162, align 8
-  %163 = getelementptr inbounds { ptr, i64 }, ptr %vararg147, i32 0, i32 1
-  %hi151 = load i64, ptr %163, align 8
-  %164 = call i64 @std_io_printfln(ptr %retparam143, ptr %lo145, i64 %hi146, ptr %lo150, i64 %hi151)
-  %not_err152 = icmp eq i64 %164, 0
-  br i1 %not_err152, label %after_check153, label %voiderr154
+if.exit89:                                        ; preds = %noerr_block88, %voiderr70
+  %91 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %92 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr %91)
+  store { ptr, i64 } %92, ptr %result, align 8
+  %93 = insertvalue %variant undef, ptr %result, 0
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1
+  %95 = getelementptr inbounds [1 x %variant], ptr %varargslots79, i64 0, i64 0
+  store %variant %94, ptr %95, align 16
+  %96 = getelementptr inbounds %"variant[]", ptr %vararg78, i32 0, i32 1
+  store i64 1, ptr %96, align 8
+  %97 = getelementptr inbounds %"variant[]", ptr %vararg78, i32 0, i32 0
+  store ptr %varargslots79, ptr %97, align 8
+  %98 = getelementptr inbounds { ptr, i64 }, ptr %vararg78, i32 0, i32 0
+  %lo90 = load ptr, ptr %98, align 8
+  %99 = getelementptr inbounds { ptr, i64 }, ptr %vararg78, i32 0, i32 1
+  %hi91 = load i64, ptr %99, align 8
+  %100 = call i64 @std_io_printfln(ptr %retparam74, ptr %lo76, i64 %hi77, ptr %lo90, i64 %hi91)
+  %not_err92 = icmp eq i64 %100, 0
+  br i1 %not_err92, label %after_check93, label %voiderr94
 
-after_check153:                                   ; preds = %if.exit142
-  br label %voiderr154
+after_check93:                                    ; preds = %if.exit89
+  br label %voiderr94
 
-voiderr154:                                       ; preds = %after_check153, %if.exit142
-  %165 = load ptr, ptr %temp, align 8
-  %166 = getelementptr inbounds %TempAllocator, ptr %165, i32 0, i32 0
-  %167 = load i64, ptr %mark, align 8
-  call void @std_core_mem_allocator_Allocator_reset(ptr %166, i64 %167)
+voiderr94:                                        ; preds = %after_check93, %if.exit89
+  call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
+  %101 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not95 = icmp eq ptr %101, null
+  br i1 %not95, label %if.then96, label %if.exit104
+
+if.then96:                                        ; preds = %voiderr94
+  %102 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam98, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err99 = icmp eq i64 %102, 0
+  br i1 %not_err99, label %after_check101, label %assign_optional100
+
+assign_optional100:                               ; preds = %if.then96
+  store i64 %102, ptr %error_var97, align 8
+  br label %panic_block102
+
+after_check101:                                   ; preds = %if.then96
+  %103 = load ptr, ptr %retparam98, align 8
+  br label %noerr_block103
+
+panic_block102:                                   ; preds = %assign_optional100
+  call void @std_core_builtin_panic(ptr @.zstr.15, ptr @.zstr.16, ptr @.zstr.17, i32 250)
+  unreachable
+
+noerr_block103:                                   ; preds = %after_check101
+  store ptr %103, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit104
+
+if.exit104:                                       ; preds = %noerr_block103, %voiderr94
+  %104 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %104)
+  %105 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00)
+  store %"char[]" { ptr @.str.18, i64 12 }, ptr %taddr106, align 8
+  %106 = getelementptr inbounds { ptr, i64 }, ptr %taddr106, i32 0, i32 0
+  %lo107 = load ptr, ptr %106, align 8
+  %107 = getelementptr inbounds { ptr, i64 }, ptr %taddr106, i32 0, i32 1
+  %hi108 = load i64, ptr %107, align 8
+  %108 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00)
+  store i8 %108, ptr %taddr111, align 1
+  %109 = insertvalue %variant undef, ptr %taddr111, 0
+  %110 = insertvalue %variant %109, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %111 = getelementptr inbounds [1 x %variant], ptr %varargslots110, i64 0, i64 0
+  store %variant %110, ptr %111, align 16
+  %112 = getelementptr inbounds %"variant[]", ptr %vararg109, i32 0, i32 1
+  store i64 1, ptr %112, align 8
+  %113 = getelementptr inbounds %"variant[]", ptr %vararg109, i32 0, i32 0
+  store ptr %varargslots110, ptr %113, align 8
+  %114 = getelementptr inbounds { ptr, i64 }, ptr %vararg109, i32 0, i32 0
+  %lo112 = load ptr, ptr %114, align 8
+  %115 = getelementptr inbounds { ptr, i64 }, ptr %vararg109, i32 0, i32 1
+  %hi113 = load i64, ptr %115, align 8
+  %116 = call i64 @std_io_printfln(ptr %retparam105, ptr %lo107, i64 %hi108, ptr %lo112, i64 %hi113)
+  %not_err114 = icmp eq i64 %116, 0
+  br i1 %not_err114, label %after_check115, label %voiderr116
+
+after_check115:                                   ; preds = %if.exit104
+  br label %voiderr116
+
+voiderr116:                                       ; preds = %after_check115, %if.exit104
+  store %"char[]" { ptr @.str.19, i64 12 }, ptr %taddr118, align 8
+  %117 = getelementptr inbounds { ptr, i64 }, ptr %taddr118, i32 0, i32 0
+  %lo119 = load ptr, ptr %117, align 8
+  %118 = getelementptr inbounds { ptr, i64 }, ptr %taddr118, i32 0, i32 1
+  %hi120 = load i64, ptr %118, align 8
+  %119 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00)
+  store i8 %119, ptr %taddr123, align 1
+  %120 = insertvalue %variant undef, ptr %taddr123, 0
+  %121 = insertvalue %variant %120, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %122 = getelementptr inbounds [1 x %variant], ptr %varargslots122, i64 0, i64 0
+  store %variant %121, ptr %122, align 16
+  %123 = getelementptr inbounds %"variant[]", ptr %vararg121, i32 0, i32 1
+  store i64 1, ptr %123, align 8
+  %124 = getelementptr inbounds %"variant[]", ptr %vararg121, i32 0, i32 0
+  store ptr %varargslots122, ptr %124, align 8
+  %125 = getelementptr inbounds { ptr, i64 }, ptr %vararg121, i32 0, i32 0
+  %lo124 = load ptr, ptr %125, align 8
+  %126 = getelementptr inbounds { ptr, i64 }, ptr %vararg121, i32 0, i32 1
+  %hi125 = load i64, ptr %126, align 8
+  %127 = call i64 @std_io_printfln(ptr %retparam117, ptr %lo119, i64 %hi120, ptr %lo124, i64 %hi125)
+  %not_err126 = icmp eq i64 %127, 0
+  br i1 %not_err126, label %after_check127, label %voiderr128
+
+after_check127:                                   ; preds = %voiderr116
+  br label %voiderr128
+
+voiderr128:                                       ; preds = %after_check127, %voiderr116
+  %128 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00)
+  store %"char[]" { ptr @.str.20, i64 2 }, ptr %taddr130, align 8
+  %129 = getelementptr inbounds { ptr, i64 }, ptr %taddr130, i32 0, i32 0
+  %lo131 = load ptr, ptr %129, align 8
+  %130 = getelementptr inbounds { ptr, i64 }, ptr %taddr130, i32 0, i32 1
+  %hi132 = load i64, ptr %130, align 8
+  %131 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not135 = icmp eq ptr %131, null
+  br i1 %not135, label %if.then136, label %if.exit144
+
+if.then136:                                       ; preds = %voiderr128
+  %132 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam138, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err139 = icmp eq i64 %132, 0
+  br i1 %not_err139, label %after_check141, label %assign_optional140
+
+assign_optional140:                               ; preds = %if.then136
+  store i64 %132, ptr %error_var137, align 8
+  br label %panic_block142
+
+after_check141:                                   ; preds = %if.then136
+  %133 = load ptr, ptr %retparam138, align 8
+  br label %noerr_block143
+
+panic_block142:                                   ; preds = %assign_optional140
+  call void @std_core_builtin_panic(ptr @.zstr.21, ptr @.zstr.22, ptr @.zstr.23, i32 250)
+  unreachable
+
+noerr_block143:                                   ; preds = %after_check141
+  store ptr %133, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit144
+
+if.exit144:                                       ; preds = %noerr_block143, %voiderr128
+  %134 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %135 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr %134)
+  store { ptr, i64 } %135, ptr %result145, align 8
+  %136 = insertvalue %variant undef, ptr %result145, 0
+  %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
+  %138 = getelementptr inbounds [1 x %variant], ptr %varargslots134, i64 0, i64 0
+  store %variant %137, ptr %138, align 16
+  %139 = getelementptr inbounds %"variant[]", ptr %vararg133, i32 0, i32 1
+  store i64 1, ptr %139, align 8
+  %140 = getelementptr inbounds %"variant[]", ptr %vararg133, i32 0, i32 0
+  store ptr %varargslots134, ptr %140, align 8
+  %141 = getelementptr inbounds { ptr, i64 }, ptr %vararg133, i32 0, i32 0
+  %lo146 = load ptr, ptr %141, align 8
+  %142 = getelementptr inbounds { ptr, i64 }, ptr %vararg133, i32 0, i32 1
+  %hi147 = load i64, ptr %142, align 8
+  %143 = call i64 @std_io_printfln(ptr %retparam129, ptr %lo131, i64 %hi132, ptr %lo146, i64 %hi147)
+  %not_err148 = icmp eq i64 %143, 0
+  br i1 %not_err148, label %after_check149, label %voiderr150
+
+after_check149:                                   ; preds = %if.exit144
+  br label %voiderr150
+
+voiderr150:                                       ; preds = %after_check149, %if.exit144
+  store %"char[]" { ptr @.str.24, i64 2 }, ptr %taddr152, align 8
+  %144 = getelementptr inbounds { ptr, i64 }, ptr %taddr152, i32 0, i32 0
+  %lo153 = load ptr, ptr %144, align 8
+  %145 = getelementptr inbounds { ptr, i64 }, ptr %taddr152, i32 0, i32 1
+  %hi154 = load i64, ptr %145, align 8
+  %146 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not157 = icmp eq ptr %146, null
+  br i1 %not157, label %if.then158, label %if.exit166
+
+if.then158:                                       ; preds = %voiderr150
+  %147 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam160, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err161 = icmp eq i64 %147, 0
+  br i1 %not_err161, label %after_check163, label %assign_optional162
+
+assign_optional162:                               ; preds = %if.then158
+  store i64 %147, ptr %error_var159, align 8
+  br label %panic_block164
+
+after_check163:                                   ; preds = %if.then158
+  %148 = load ptr, ptr %retparam160, align 8
+  br label %noerr_block165
+
+panic_block164:                                   ; preds = %assign_optional162
+  call void @std_core_builtin_panic(ptr @.zstr.25, ptr @.zstr.26, ptr @.zstr.27, i32 250)
+  unreachable
+
+noerr_block165:                                   ; preds = %after_check163
+  store ptr %148, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit166
+
+if.exit166:                                       ; preds = %noerr_block165, %voiderr150
+  %149 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %150 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr %149)
+  store { ptr, i64 } %150, ptr %result167, align 8
+  %151 = insertvalue %variant undef, ptr %result167, 0
+  %152 = insertvalue %variant %151, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1
+  %153 = getelementptr inbounds [1 x %variant], ptr %varargslots156, i64 0, i64 0
+  store %variant %152, ptr %153, align 16
+  %154 = getelementptr inbounds %"variant[]", ptr %vararg155, i32 0, i32 1
+  store i64 1, ptr %154, align 8
+  %155 = getelementptr inbounds %"variant[]", ptr %vararg155, i32 0, i32 0
+  store ptr %varargslots156, ptr %155, align 8
+  %156 = getelementptr inbounds { ptr, i64 }, ptr %vararg155, i32 0, i32 0
+  %lo168 = load ptr, ptr %156, align 8
+  %157 = getelementptr inbounds { ptr, i64 }, ptr %vararg155, i32 0, i32 1
+  %hi169 = load i64, ptr %157, align 8
+  %158 = call i64 @std_io_printfln(ptr %retparam151, ptr %lo153, i64 %hi154, ptr %lo168, i64 %hi169)
+  %not_err170 = icmp eq i64 %158, 0
+  br i1 %not_err170, label %after_check171, label %voiderr172
+
+after_check171:                                   ; preds = %if.exit166
+  br label %voiderr172
+
+voiderr172:                                       ; preds = %after_check171, %if.exit166
+  %159 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not173 = icmp eq ptr %159, null
+  br i1 %not173, label %if.then174, label %if.exit182
+
+if.then174:                                       ; preds = %voiderr172
+  %160 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam176, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err177 = icmp eq i64 %160, 0
+  br i1 %not_err177, label %after_check179, label %assign_optional178
+
+assign_optional178:                               ; preds = %if.then174
+  store i64 %160, ptr %error_var175, align 8
+  br label %panic_block180
+
+after_check179:                                   ; preds = %if.then174
+  %161 = load ptr, ptr %retparam176, align 8
+  br label %noerr_block181
+
+panic_block180:                                   ; preds = %assign_optional178
+  call void @std_core_builtin_panic(ptr @.zstr.28, ptr @.zstr.29, ptr @.zstr.30, i32 250)
+  unreachable
+
+noerr_block181:                                   ; preds = %after_check179
+  store ptr %161, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit182
+
+if.exit182:                                       ; preds = %noerr_block181, %voiderr172
+  %162 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  store ptr %162, ptr %temp, align 8
+  %163 = load ptr, ptr %temp, align 8
+  %164 = getelementptr inbounds %TempAllocator, ptr %163, i32 0, i32 3
+  %165 = load i64, ptr %164, align 8
+  store i64 %165, ptr %mark, align 8
+  call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false)
+  %166 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not183 = icmp eq ptr %166, null
+  br i1 %not183, label %if.then184, label %if.exit192
+
+if.then184:                                       ; preds = %if.exit182
+  %167 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam186, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err187 = icmp eq i64 %167, 0
+  br i1 %not_err187, label %after_check189, label %assign_optional188
+
+assign_optional188:                               ; preds = %if.then184
+  store i64 %167, ptr %error_var185, align 8
+  br label %panic_block190
+
+after_check189:                                   ; preds = %if.then184
+  %168 = load ptr, ptr %retparam186, align 8
+  br label %noerr_block191
+
+panic_block190:                                   ; preds = %assign_optional188
+  call void @std_core_builtin_panic(ptr @.zstr.31, ptr @.zstr.32, ptr @.zstr.33, i32 250)
+  unreachable
+
+noerr_block191:                                   ; preds = %after_check189
+  store ptr %168, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit192
+
+if.exit192:                                       ; preds = %noerr_block191, %if.exit182
+  %169 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  call void @"std_map$$int.double_HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %169)
+  %170 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 5, double 3.200000e+00)
+  %171 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00)
+  store %"char[]" { ptr @.str.34, i64 2 }, ptr %taddr194, align 8
+  %172 = getelementptr inbounds { ptr, i64 }, ptr %taddr194, i32 0, i32 0
+  %lo195 = load ptr, ptr %172, align 8
+  %173 = getelementptr inbounds { ptr, i64 }, ptr %taddr194, i32 0, i32 1
+  %hi196 = load i64, ptr %173, align 8
+  %174 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %not199 = icmp eq ptr %174, null
+  br i1 %not199, label %if.then200, label %if.exit208
+
+if.then200:                                       ; preds = %if.exit192
+  %175 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam202, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
+  %not_err203 = icmp eq i64 %175, 0
+  br i1 %not_err203, label %after_check205, label %assign_optional204
+
+assign_optional204:                               ; preds = %if.then200
+  store i64 %175, ptr %error_var201, align 8
+  br label %panic_block206
+
+after_check205:                                   ; preds = %if.then200
+  %176 = load ptr, ptr %retparam202, align 8
+  br label %noerr_block207
+
+panic_block206:                                   ; preds = %assign_optional204
+  call void @std_core_builtin_panic(ptr @.zstr.35, ptr @.zstr.36, ptr @.zstr.37, i32 250)
+  unreachable
+
+noerr_block207:                                   ; preds = %after_check205
+  store ptr %176, ptr @std_core_mem_thread_temp_allocator, align 8
+  br label %if.exit208
+
+if.exit208:                                       ; preds = %noerr_block207, %if.exit192
+  %177 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
+  %178 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map3, ptr %177)
+  store { ptr, i64 } %178, ptr %result209, align 8
+  %179 = insertvalue %variant undef, ptr %result209, 0
+  %180 = insertvalue %variant %179, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
+  %181 = getelementptr inbounds [1 x %variant], ptr %varargslots198, i64 0, i64 0
+  store %variant %180, ptr %181, align 16
+  %182 = getelementptr inbounds %"variant[]", ptr %vararg197, i32 0, i32 1
+  store i64 1, ptr %182, align 8
+  %183 = getelementptr inbounds %"variant[]", ptr %vararg197, i32 0, i32 0
+  store ptr %varargslots198, ptr %183, align 8
+  %184 = getelementptr inbounds { ptr, i64 }, ptr %vararg197, i32 0, i32 0
+  %lo210 = load ptr, ptr %184, align 8
+  %185 = getelementptr inbounds { ptr, i64 }, ptr %vararg197, i32 0, i32 1
+  %hi211 = load i64, ptr %185, align 8
+  %186 = call i64 @std_io_printfln(ptr %retparam193, ptr %lo195, i64 %hi196, ptr %lo210, i64 %hi211)
+  %not_err212 = icmp eq i64 %186, 0
+  br i1 %not_err212, label %after_check213, label %voiderr214
+
+after_check213:                                   ; preds = %if.exit208
+  br label %voiderr214
+
+voiderr214:                                       ; preds = %after_check213, %if.exit208
+  %187 = load ptr, ptr %temp, align 8
+  %188 = getelementptr inbounds %TempAllocator, ptr %187, i32 0, i32 0
+  %189 = load i64, ptr %mark, align 8
+  call void @std_core_mem_allocator_Allocator_reset(ptr %188, i64 %189)
   ret void
 }