shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

First 0.7 update, removing all deprecated features.

Browse Source
This commit is contained in:
Christoffer Lerno
2025-02-27 14:16:36 +01:00
committed by Christoffer Lerno
parent cff6697818
commit 2a895ec7be
1589 changed files with 2635 additions and 115363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

271
test/test_suite/stdlib/map_macos.c3t
View File

@@ -6,12 +6,12 @@ import std::collections::map;
struct Foo (Printable) { int x; void* bar; }
def IntFooMap = HashMap(<int, Foo>);
def IntDoubleMap = HashMap(<int, double>);
def IntFooMap = HashMap { int, Foo };
def IntDoubleMap = HashMap { int, double };
fn String Foo.to_new_string(Foo* foo, Allocator allocator = allocator::heap()) @dynamic
{
DString s = dstring::new_with_capacity(128, allocator);
DString s = dstring::new_with_capacity(allocator, 128);
s.appendf("{%s, %p}", foo.x, foo.bar);
return s.str_view();
}
@@ -21,7 +21,7 @@ fn String Foo.to_new_string(Foo* foo, Allocator allocator = allocator::heap()) @
fn void main()
{
IntFooMap map;
map.new_init();
map.init(mem);
io::printfn("Map size: %d", map.count);
map.set(1, { 1, null });
io::printfn("Map size: %d", map.count);
@@ -31,22 +31,22 @@ fn void main()
io::printfn("Has 1: %s", map.has_key(1));
io::printfn("Has 2: %s", map.has_key(2));
map.set(7, { 4, null });
io::printfn("Values: %s", map.value_new_list());
io::printfn("Values: %s", map.values(mem));
IntDoubleMap map2;
map2.new_init();
map2.init(mem);
map2.set(4, 1.3);
io::printfn("Map find: %s", map2.has_value(1.3));
io::printfn("Map find: %s", map2.has_value(1.2));
map2.set(100, 3.4);
io::printfn("%s", map2.key_new_list());
io::printfn("%s", map2.value_new_list());
io::printfn("%s", map2.keys(mem));
io::printfn("%s", map2.values(mem));
@pool()
{
IntDoubleMap map3;
map3.new_init();
map3.init(mem);
map3.set(5, 3.2);
map3.set(7, 5.2);
io::printfn("%s", map3.key_new_list());
io::printfn("%s", map3.keys(mem));
};
}
@@ -68,7 +68,7 @@ entry:
%lo = load i64, ptr %allocator, align 8
%ptradd1 = getelementptr inbounds i8, ptr %allocator, i64 8
%hi = load ptr, ptr %ptradd1, align 8
%3 = call ptr @std.core.dstring.new_with_capacity(i64 128, i64 %lo, ptr %hi)
%3 = call ptr @std.core.dstring.new_with_capacity(i64 %lo, ptr %hi, i64 128)
store ptr %3, ptr %s, align 8
%4 = insertvalue %any undef, ptr %0, 0
%5 = insertvalue %any %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -89,187 +89,178 @@ entry:
define void @test.main() #0 {
entry:
%map = alloca %HashMap, align 8
%taddr = alloca %any, align 8
%varargslots = alloca [1 x %any], align 16
%retparam = alloca i64, align 8
%literal = alloca %Foo, align 8
%varargslots5 = alloca [1 x %any], align 16
%retparam7 = alloca i64, align 8
%literal8 = alloca %Foo, align 8
%varargslots12 = alloca [1 x %any], align 16
%retparam14 = alloca i64, align 8
%varargslots15 = alloca [1 x %any], align 16
%retparam16 = alloca %Foo, align 8
%retparam17 = alloca i64, align 8
%varargslots20 = alloca [1 x %any], align 16
%taddr21 = alloca i8, align 1
%retparam22 = alloca i64, align 8
%varargslots25 = alloca [1 x %any], align 16
%taddr26 = alloca i8, align 1
%retparam27 = alloca i64, align 8
%literal30 = alloca %Foo, align 8
%varargslots34 = alloca [1 x %any], align 16
%varargslots4 = alloca [1 x %any], align 16
%retparam6 = alloca i64, align 8
%literal7 = alloca %Foo, align 8
%varargslots11 = alloca [1 x %any], align 16
%retparam13 = alloca i64, align 8
%varargslots14 = alloca [1 x %any], align 16
%retparam15 = alloca %Foo, align 8
%retparam16 = alloca i64, align 8
%varargslots19 = alloca [1 x %any], align 16
%taddr = alloca i8, align 1
%retparam20 = alloca i64, align 8
%varargslots23 = alloca [1 x %any], align 16
%taddr24 = alloca i8, align 1
%retparam25 = alloca i64, align 8
%literal28 = alloca %Foo, align 8
%varargslots32 = alloca [1 x %any], align 16
%result = alloca %"Foo[]", align 8
%retparam37 = alloca i64, align 8
%retparam35 = alloca i64, align 8
%map2 = alloca %HashMap.0, align 8
%taddr40 = alloca %any, align 8
%varargslots44 = alloca [1 x %any], align 16
%taddr45 = alloca i8, align 1
%retparam46 = alloca i64, align 8
%varargslots49 = alloca [1 x %any], align 16
%taddr50 = alloca i8, align 1
%retparam51 = alloca i64, align 8
%varargslots54 = alloca [1 x %any], align 16
%result57 = alloca %"int[]", align 8
%retparam58 = alloca i64, align 8
%varargslots61 = alloca [1 x %any], align 16
%result64 = alloca %"double[]", align 8
%retparam65 = alloca i64, align 8
%varargslots40 = alloca [1 x %any], align 16
%taddr41 = alloca i8, align 1
%retparam42 = alloca i64, align 8
%varargslots45 = alloca [1 x %any], align 16
%taddr46 = alloca i8, align 1
%retparam47 = alloca i64, align 8
%varargslots50 = alloca [1 x %any], align 16
%result53 = alloca %"int[]", align 8
%retparam54 = alloca i64, align 8
%varargslots57 = alloca [1 x %any], align 16
%result60 = alloca %"double[]", align 8
%retparam61 = alloca i64, align 8
%current = alloca ptr, align 8
%mark = alloca i64, align 8
%map3 = alloca %HashMap.0, align 8
%taddr69 = alloca %any, align 8
%varargslots73 = alloca [1 x %any], align 16
%result76 = alloca %"int[]", align 8
%retparam77 = alloca i64, align 8
%varargslots67 = alloca [1 x %any], align 16
%result70 = alloca %"int[]", align 8
%retparam71 = alloca i64, align 8
call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr, align 8
%lo = load i64, ptr %taddr, align 8
%ptradd = getelementptr inbounds i8, ptr %taddr, i64 8
%hi = load ptr, ptr %ptradd, align 8
%0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.new_init"(ptr %map, i32 16, float 7.500000e-01, i64 %lo, ptr %hi)
%ptradd1 = getelementptr inbounds i8, ptr %map, i64 32
%1 = insertvalue %any undef, ptr %ptradd1, 0
%lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01)
%ptradd = getelementptr inbounds i8, ptr %map, i64 32
%1 = insertvalue %any undef, ptr %ptradd, 0
%2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
store %any %2, ptr %varargslots, align 16
%3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
%lo2 = load i32, ptr %literal, align 8
%ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8
%hi4 = load ptr, ptr %ptradd3, align 8
%4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4)
%ptradd6 = getelementptr inbounds i8, ptr %map, i64 32
%5 = insertvalue %any undef, ptr %ptradd6, 0
%lo1 = load i32, ptr %literal, align 8
%ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8
%hi3 = load ptr, ptr %ptradd2, align 8
%4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3)
%ptradd5 = getelementptr inbounds i8, ptr %map, i64 32
%5 = insertvalue %any undef, ptr %ptradd5, 0
%6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
store %any %6, ptr %varargslots5, align 16
%7 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false)
%lo9 = load i32, ptr %literal8, align 8
%ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8
%hi11 = load ptr, ptr %ptradd10, align 8
%8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11)
%ptradd13 = getelementptr inbounds i8, ptr %map, i64 32
%9 = insertvalue %any undef, ptr %ptradd13, 0
store %any %6, ptr %varargslots4, align 16
%7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false)
%lo8 = load i32, ptr %literal7, align 8
%ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8
%hi10 = load ptr, ptr %ptradd9, align 8
%8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10)
%ptradd12 = getelementptr inbounds i8, ptr %map, i64 32
%9 = insertvalue %any undef, ptr %ptradd12, 0
%10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
store %any %10, ptr %varargslots12, align 16
%11 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1)
%12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1)
store %any %10, ptr %varargslots11, align 16
%11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.3, i64 12, ptr %varargslots11, i64 1)
%12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam15, ptr %map, i32 1)
%not_err = icmp eq i64 %12, 0
%13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
br i1 %13, label %after_check, label %after_check19
br i1 %13, label %after_check, label %after_check18
after_check: ; preds = %entry
%14 = insertvalue %any undef, ptr %retparam16, 0
%14 = insertvalue %any undef, ptr %retparam15, 0
%15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1
store %any %15, ptr %varargslots15, align 16
%16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1)
%not_err18 = icmp eq i64 %16, 0
%17 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
br i1 %17, label %after_check19, label %after_check19
store %any %15, ptr %varargslots14, align 16
%16 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.4, i64 7, ptr %varargslots14, i64 1)
%not_err17 = icmp eq i64 %16, 0
%17 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true)
br i1 %17, label %after_check18, label %after_check18
after_check19: ; preds = %entry, %after_check, %after_check
after_check18: ; preds = %entry, %after_check, %after_check
%18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
store i8 %18, ptr %taddr21, align 1
%19 = insertvalue %any undef, ptr %taddr21, 0
store i8 %18, ptr %taddr, align 1
%19 = insertvalue %any undef, ptr %taddr, 0
%20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
store %any %20, ptr %varargslots20, align 16
%21 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.5, i64 9, ptr %varargslots20, i64 1)
store %any %20, ptr %varargslots19, align 16
%21 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.5, i64 9, ptr %varargslots19, i64 1)
%22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
store i8 %22, ptr %taddr26, align 1
%23 = insertvalue %any undef, ptr %taddr26, 0
store i8 %22, ptr %taddr24, align 1
%23 = insertvalue %any undef, ptr %taddr24, 0
%24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
store %any %24, ptr %varargslots25, align 16
%25 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.6, i64 9, ptr %varargslots25, i64 1)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal30, ptr align 8 @.__const.7, i32 16, i1 false)
%lo31 = load i32, ptr %literal30, align 8
%ptradd32 = getelementptr inbounds i8, ptr %literal30, i64 8
%hi33 = load ptr, ptr %ptradd32, align 8
%26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo31, ptr %hi33)
%lo35 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi36 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo35, ptr %hi36)
store %any %24, ptr %varargslots23, align 16
%25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false)
%lo29 = load i32, ptr %literal28, align 8
%ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8
%hi31 = load ptr, ptr %ptradd30, align 8
%26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31)
%lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo33, ptr %hi34)
store { ptr, i64 } %27, ptr %result, align 8
%28 = insertvalue %any undef, ptr %result, 0
%29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
store %any %29, ptr %varargslots34, align 16
%30 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots34, i64 1)
store %any %29, ptr %varargslots32, align 16
%30 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.8, i64 10, ptr %varargslots32, i64 1)
call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr40, align 8
%lo41 = load i64, ptr %taddr40, align 8
%ptradd42 = getelementptr inbounds i8, ptr %taddr40, i64 8
%hi43 = load ptr, ptr %ptradd42, align 8
%31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo41, ptr %hi43)
%lo38 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi39 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%31 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo38, ptr %hi39, i32 16, float 7.500000e-01)
%32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
%33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
store i8 %33, ptr %taddr45, align 1
%34 = insertvalue %any undef, ptr %taddr45, 0
store i8 %33, ptr %taddr41, align 1
%34 = insertvalue %any undef, ptr %taddr41, 0
%35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
store %any %35, ptr %varargslots44, align 16
%36 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.9, i64 12, ptr %varargslots44, i64 1)
store %any %35, ptr %varargslots40, align 16
%36 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.9, i64 12, ptr %varargslots40, i64 1)
%37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
store i8 %37, ptr %taddr50, align 1
%38 = insertvalue %any undef, ptr %taddr50, 0
store i8 %37, ptr %taddr46, align 1
%38 = insertvalue %any undef, ptr %taddr46, 0
%39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
store %any %39, ptr %varargslots49, align 16
%40 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.10, i64 12, ptr %varargslots49, i64 1)
store %any %39, ptr %varargslots45, align 16
%40 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.10, i64 12, ptr %varargslots45, i64 1)
%41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
%lo55 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi56 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo55, ptr %hi56)
store { ptr, i64 } %42, ptr %result57, align 8
%43 = insertvalue %any undef, ptr %result57, 0
%lo51 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi52 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo51, ptr %hi52)
store { ptr, i64 } %42, ptr %result53, align 8
%43 = insertvalue %any undef, ptr %result53, 0
%44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
store %any %44, ptr %varargslots54, align 16
%45 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
%lo62 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi63 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo62, ptr %hi63)
store { ptr, i64 } %46, ptr %result64, align 8
%47 = insertvalue %any undef, ptr %result64, 0
store %any %44, ptr %varargslots50, align 16
%45 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.11, i64 2, ptr %varargslots50, i64 1)
%lo58 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi59 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo58, ptr %hi59)
store { ptr, i64 } %46, ptr %result60, align 8
%47 = insertvalue %any undef, ptr %result60, 0
%48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
store %any %48, ptr %varargslots61, align 16
%49 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.12, i64 2, ptr %varargslots61, i64 1)
store %any %48, ptr %varargslots57, align 16
%49 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.12, i64 2, ptr %varargslots57, i64 1)
%50 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
%i2nb = icmp eq ptr %50, null
br i1 %i2nb, label %if.then, label %if.exit
if.then: ; preds = %after_check19
if.then: ; preds = %after_check18
call void @std.core.mem.allocator.init_default_temp_allocators()
br label %if.exit
if.exit: ; preds = %if.then, %after_check19
if.exit: ; preds = %if.then, %after_check18
%51 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
store ptr %51, ptr %current, align 8
%52 = load ptr, ptr %current, align 8
%ptradd68 = getelementptr inbounds i8, ptr %52, i64 24
%53 = load i64, ptr %ptradd68, align 8
%ptradd64 = getelementptr inbounds i8, ptr %52, i64 24
%53 = load i64, ptr %ptradd64, align 8
store i64 %53, ptr %mark, align 8
call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr69, align 8
%lo70 = load i64, ptr %taddr69, align 8
%ptradd71 = getelementptr inbounds i8, ptr %taddr69, i64 8
%hi72 = load ptr, ptr %ptradd71, align 8
%54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo70, ptr %hi72)
%lo65 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi66 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%54 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo65, ptr %hi66, i32 16, float 7.500000e-01)
%55 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
%56 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
%lo74 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi75 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo74, ptr %hi75)
store { ptr, i64 } %57, ptr %result76, align 8
%58 = insertvalue %any undef, ptr %result76, 0
%lo68 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
%hi69 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
%57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo68, ptr %hi69)
store { ptr, i64 } %57, ptr %result70, align 8
%58 = insertvalue %any undef, ptr %result70, 0
%59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
store %any %59, ptr %varargslots73, align 16
%60 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots73, i64 1)
store %any %59, ptr %varargslots67, align 16
%60 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.13, i64 2, ptr %varargslots67, i64 1)
%61 = load ptr, ptr %current, align 8
%62 = load i64, ptr %mark, align 8
call void @std.core.mem.allocator.TempAllocator.reset(ptr %61, i64 %62)