// #target: macos-x64

module test;
import std::io;
import std::map;

struct Foo { int x; void* bar; }

define IntFooMap = std::map::HashMap<int, Foo>;
define IntDoubleMap = std::map::HashMap<int, double>;

fn char[] Foo.to_string(Foo* foo, Allocator* allocator = mem::current_allocator())
{
	String s = string::new_with_capacity(128, allocator);
	s.printf("{%s, %p}", foo.x, foo.bar);
	return s.str();
}

static initialize
{
	io::formatter_register_type(Foo);
}

fn void main()
{
	IntFooMap map;
	map.init();
	io::printfln("Map size: %d", map.count);
	map.set(1, Foo { 1, null });
	io::printfln("Map size: %d", map.count);
	map.set(1, Foo { 2, null });
	io::printfln("Map size: %d", map.count);
	io::printfln("Val: %d", map.get(1).x);
	io::printfln("Has 1: %s", map.has_key(1));
	io::printfln("Has 2: %s", map.has_key(2));
	map.set(7, Foo { 4, null });
	io::printfln("Values: %s", map.value_list());
	IntDoubleMap map2;
	map2.init();
	map2.set(4, 1.3);
	io::printfln("Map find: %s", map2.has_value(1.3));
	io::printfln("Map find: %s", map2.has_value(1.2));
	map2.set(100, 3.4);
	io::printfln("%s", map2.key_list());
	io::printfln("%s", map2.value_list());
	@pool()
	{
		IntDoubleMap map3;
		map3.init();
		map3.set(5, 3.2);
		map3.set(7, 5.2);
		io::printfln("%s", map3.key_list());
	};
}

/* #expect: test.ll
@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @.static_initialize.0, ptr null }]

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.exit3

if.then:                                          ; preds = %entry
  %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 = %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
}

define { ptr, i64 } @test_Foo_to_string(ptr %0, ptr %1) #0 {
entry:
  %s = alloca ptr, align 8
  %retparam = alloca i64, align 8
  %taddr = alloca %"char[]", align 8
  %vararg = alloca %"variant[]", align 8
  %varargslots = alloca [2 x %variant], align 16
  %result = alloca %"char[]", align 8
  %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.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
  %hi = load i64, ptr %4, align 8
  %5 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0
  %6 = insertvalue %variant undef, ptr %5, 0
  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %7, ptr %8, align 16
  %9 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1
  %10 = insertvalue %variant undef, ptr %9, 0
  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$p$void" to i64), 1
  %12 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
  store %variant %11, ptr %12, align 16
  %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
  store i64 2, ptr %13, align 8
  %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
  store ptr %varargslots, ptr %14, align 8
  %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
  %lo1 = load ptr, ptr %15, align 8
  %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
  %hi2 = load i64, ptr %16, align 8
  %17 = call i64 @std_core_string_String_printf(ptr %retparam, ptr %s, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
  %not_err = icmp eq i64 %17, 0
  br i1 %not_err, label %after_check, label %voiderr

after_check:                                      ; preds = %entry
  br label %voiderr

voiderr:                                          ; preds = %after_check, %entry
  %18 = load ptr, ptr %s, align 8
  %19 = call { ptr, i64 } @std_core_string_String_str(ptr %18)
  store { ptr, i64 } %19, ptr %result, align 8
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %tempcoerce, ptr align 8 %result, i32 16, i1 false)
  %20 = load { ptr, i64 }, ptr %tempcoerce, align 8
  ret { ptr, i64 } %20
}

; Function Attrs: nounwind
define void @test_main() #0 {
entry:
  %map = alloca %HashMap.0, 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
  %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
  %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_var175 = alloca i64, align 8
  %retparam176 = alloca ptr, align 8
  %mark = alloca i64, align 8
  %map3 = alloca %HashMap.3, 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_temp_allocator, align 8
  %not = icmp eq ptr %0, null
  br i1 %not, label %if.then, label %if.exit

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 %1, ptr %error_var, align 8
  br label %panic_block

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.3, ptr @.zstr.4, ptr @.zstr.5, i32 250)
  unreachable

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, %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

after_check5:                                     ; preds = %if.exit
  br label %voiderr

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_check17:                                    ; preds = %voiderr
  br label %voiderr18

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_block88:                                    ; preds = %after_check86
  store ptr %90, ptr @std_core_mem_thread_temp_allocator, align 8
  br label %if.exit89

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_check93:                                    ; preds = %if.exit89
  br label %voiderr94

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
}