lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
878c4226a6223a8e424f373faf9ef40cbcda2a43
sx/examples/expected/1009-errors-catch.ir
agra 878c4226a6 fix(0109): hoist all per-instruction allocas to the function entry block 
An alloca built at its use site re-executes on every pass through that
block, and LLVM reclaims allocas only at ret — so loop-body locals,
nested-loop index slots, and emitter spill temps (ig.tmp, sret slots, ABI
coercion temps, byval materialization) grew the stack per iteration and
long loops segfaulted on stack exhaustion.

New LLVMEmitter.buildEntryAlloca inserts after existing entry-block
allocas and restores the builder position; every LLVMBuildAlloca site
reachable during instruction emission now routes through it.
Initialization stores stay at the use site (per-iteration re-init is
unchanged), and entry slots become mem2reg-promotable. The 35 .ir
snapshot diffs are pure alloca position moves (type multisets verified
identical per file).

Regression: examples/0047-basic-loop-local-stack-reuse.sx (segfaulted
pre-fix on both the 1M-iteration body-local loop and the 3M-iteration
nested loop).
2026-06-10 17:27:11 +03:00

3626 lines
164 KiB
Plaintext
Raw Blame History

@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
@str = private unnamed_addr constant [2 x i8] c"0\00", align 1
@str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
@str.2 = private unnamed_addr constant [5 x i8] c"true\00", align 1
@str.3 = private unnamed_addr constant [6 x i8] c"false\00", align 1
@str.4 = private unnamed_addr constant [2 x i8] c"0\00", align 1
@str.5 = private unnamed_addr constant [4 x i8] c"<?>\00", align 1
@str.6 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@__sx_type_is_unsigned = private constant [75 x i1] [i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false]
@tag.str = private constant [1 x i8] zeroinitializer
@tag.str.7 = private constant [4 x i8] c"Bad\00"
@tag.str.8 = private constant [6 x i8] c"Empty\00"
@tag_names = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @tag.str, i64 0 }, { ptr, i64 } { ptr @tag.str.7, i64 3 }, { ptr, i64 } { ptr @tag.str.8, i64 5 }]
@tn.str = private constant [13 x i8] c"<unresolved>\00"
@tn.str.9 = private constant [5 x i8] c"bool\00"
@tn.str.10 = private constant [3 x i8] c"s8\00"
@tn.str.11 = private constant [4 x i8] c"s16\00"
@tn.str.12 = private constant [4 x i8] c"s32\00"
@tn.str.13 = private constant [4 x i8] c"s64\00"
@tn.str.14 = private constant [3 x i8] c"u8\00"
@tn.str.15 = private constant [4 x i8] c"u16\00"
@tn.str.16 = private constant [4 x i8] c"u32\00"
@tn.str.17 = private constant [4 x i8] c"u64\00"
@tn.str.18 = private constant [4 x i8] c"f32\00"
@tn.str.19 = private constant [4 x i8] c"f64\00"
@tn.str.20 = private constant [7 x i8] c"string\00"
@tn.str.21 = private constant [4 x i8] c"Any\00"
@tn.str.22 = private constant [9 x i8] c"noreturn\00"
@tn.str.23 = private constant [6 x i8] c"isize\00"
@tn.str.24 = private constant [6 x i8] c"usize\00"
@tn.str.25 = private constant [5 x i8] c"void\00"
@tn.str.26 = private constant [6 x i8] c"*void\00"
@tn.str.27 = private constant [16 x i8] c"Source_Location\00"
@tn.str.28 = private constant [10 x i8] c"Allocator\00"
@tn.str.29 = private constant [11 x i8] c"CAllocator\00"
@tn.str.30 = private constant [12 x i8] c"*CAllocator\00"
@tn.str.31 = private constant [4 x i8] c"GPA\00"
@tn.str.32 = private constant [5 x i8] c"*GPA\00"
@tn.str.33 = private constant [11 x i8] c"ArenaChunk\00"
@tn.str.34 = private constant [12 x i8] c"*ArenaChunk\00"
@tn.str.35 = private constant [6 x i8] c"Arena\00"
@tn.str.36 = private constant [7 x i8] c"*Arena\00"
@tn.str.37 = private constant [6 x i8] c"[*]u8\00"
@tn.str.38 = private constant [9 x i8] c"BufAlloc\00"
@tn.str.39 = private constant [10 x i8] c"*BufAlloc\00"
@tn.str.40 = private constant [18 x i8] c"TrackingAllocator\00"
@tn.str.41 = private constant [19 x i8] c"*TrackingAllocator\00"
@tn.str.42 = private constant [8 x i8] c"Context\00"
@tn.str.43 = private constant [7 x i8] c"[4]s64\00"
@tn.str.44 = private constant [9 x i8] c"[]string\00"
@tn.str.45 = private constant [2 x i8] c"E\00"
@tn.str.46 = private constant [13 x i8] c"**CAllocator\00"
@tn.str.47 = private constant [5 x i8] c"*s64\00"
@tn.str.48 = private constant [7 x i8] c"**void\00"
@tn.str.49 = private constant [5 x i8] c"*s32\00"
@tn.str.50 = private constant [3 x i8] c"*E\00"
@tn.str.51 = private constant [8 x i8] c"*string\00"
@tn.str.52 = private constant [6 x i8] c"[]Any\00"
@tn.str.53 = private constant [5 x i8] c"*Any\00"
@tn.str.54 = private constant [7 x i8] c"[1]Any\00"
@tn.str.55 = private constant [8 x i8] c"*[1]Any\00"
@tn.str.56 = private constant [7 x i8] c"*[]Any\00"
@tn.str.57 = private constant [4 x i8] c"*u8\00"
@tn.str.58 = private constant [6 x i8] c"*bool\00"
@tn.str.59 = private constant [8 x i8] c"*[4]s64\00"
@tn.str.60 = private constant [5 x i8] c"*f64\00"
@tn.str.61 = private constant [17 x i8] c"*Source_Location\00"
@tn.str.62 = private constant [11 x i8] c"*Allocator\00"
@tn.str.63 = private constant [9 x i8] c"*Context\00"
@tn.str.64 = private constant [5 x i8] c"*u32\00"
@tn.str.65 = private constant [10 x i8] c"*[]string\00"
@tn.str.66 = private constant [6 x i8] c"**GPA\00"
@tn.str.67 = private constant [13 x i8] c"**ArenaChunk\00"
@tn.str.68 = private constant [8 x i8] c"**Arena\00"
@tn.str.69 = private constant [7 x i8] c"*[*]u8\00"
@tn.str.70 = private constant [11 x i8] c"**BufAlloc\00"
@tn.str.71 = private constant [20 x i8] c"**TrackingAllocator\00"
@tn.str.72 = private constant [14 x i8] c"***CAllocator\00"
@tn.str.73 = private constant [6 x i8] c"**s64\00"
@tn.str.74 = private constant [8 x i8] c"***void\00"
@tn.str.75 = private constant [6 x i8] c"**s32\00"
@tn.str.76 = private constant [4 x i8] c"**E\00"
@tn.str.77 = private constant [9 x i8] c"**string\00"
@tn.str.78 = private constant [6 x i8] c"**Any\00"
@tn.str.79 = private constant [9 x i8] c"**[1]Any\00"
@tn.str.80 = private constant [8 x i8] c"**[]Any\00"
@tn.str.81 = private constant [5 x i8] c"**u8\00"
@tn.str.82 = private constant [7 x i8] c"**bool\00"
@__sx_type_names = private constant [75 x { ptr, i64 }] [{ ptr, i64 } { ptr @tn.str, i64 12 }, { ptr, i64 } { ptr @tn.str.9, i64 4 }, { ptr, i64 } { ptr @tn.str.10, i64 2 }, { ptr, i64 } { ptr @tn.str.11, i64 3 }, { ptr, i64 } { ptr @tn.str.12, i64 3 }, { ptr, i64 } { ptr @tn.str.13, i64 3 }, { ptr, i64 } { ptr @tn.str.14, i64 2 }, { ptr, i64 } { ptr @tn.str.15, i64 3 }, { ptr, i64 } { ptr @tn.str.16, i64 3 }, { ptr, i64 } { ptr @tn.str.17, i64 3 }, { ptr, i64 } { ptr @tn.str.18, i64 3 }, { ptr, i64 } { ptr @tn.str.19, i64 3 }, { ptr, i64 } { ptr @tn.str.20, i64 6 }, { ptr, i64 } { ptr @tn.str.21, i64 3 }, { ptr, i64 } { ptr @tn.str.22, i64 8 }, { ptr, i64 } { ptr @tn.str.23, i64 5 }, { ptr, i64 } { ptr @tn.str.24, i64 5 }, { ptr, i64 } { ptr @tn.str.25, i64 4 }, { ptr, i64 } { ptr @tn.str.26, i64 5 }, { ptr, i64 } { ptr @tn.str.27, i64 15 }, { ptr, i64 } { ptr @tn.str.28, i64 9 }, { ptr, i64 } { ptr @tn.str.29, i64 10 }, { ptr, i64 } { ptr @tn.str.30, i64 11 }, { ptr, i64 } { ptr @tn.str.31, i64 3 }, { ptr, i64 } { ptr @tn.str.32, i64 4 }, { ptr, i64 } { ptr @tn.str.33, i64 10 }, { ptr, i64 } { ptr @tn.str.34, i64 11 }, { ptr, i64 } { ptr @tn.str.35, i64 5 }, { ptr, i64 } { ptr @tn.str.36, i64 6 }, { ptr, i64 } { ptr @tn.str.37, i64 5 }, { ptr, i64 } { ptr @tn.str.38, i64 8 }, { ptr, i64 } { ptr @tn.str.39, i64 9 }, { ptr, i64 } { ptr @tn.str.40, i64 17 }, { ptr, i64 } { ptr @tn.str.41, i64 18 }, { ptr, i64 } { ptr @tn.str.42, i64 7 }, { ptr, i64 } { ptr @tn.str.43, i64 6 }, { ptr, i64 } { ptr @tn.str.44, i64 8 }, { ptr, i64 } { ptr @tn.str.45, i64 1 }, { ptr, i64 } { ptr @tn.str.46, i64 12 }, { ptr, i64 } { ptr @tn.str.47, i64 4 }, { ptr, i64 } { ptr @tn.str.48, i64 6 }, { ptr, i64 } { ptr @tn.str.49, i64 4 }, { ptr, i64 } { ptr @tn.str.50, i64 2 }, { ptr, i64 } { ptr @tn.str.51, i64 7 }, { ptr, i64 } { ptr @tn.str.52, i64 5 }, { ptr, i64 } { ptr @tn.str.53, i64 4 }, { ptr, i64 } { ptr @tn.str.54, i64 6 }, { ptr, i64 } { ptr @tn.str.55, i64 7 }, { ptr, i64 } { ptr @tn.str.56, i64 6 }, { ptr, i64 } { ptr @tn.str.57, i64 3 }, { ptr, i64 } { ptr @tn.str.58, i64 5 }, { ptr, i64 } { ptr @tn.str.59, i64 7 }, { ptr, i64 } { ptr @tn.str.60, i64 4 }, { ptr, i64 } { ptr @tn.str.61, i64 16 }, { ptr, i64 } { ptr @tn.str.62, i64 10 }, { ptr, i64 } { ptr @tn.str.63, i64 8 }, { ptr, i64 } { ptr @tn.str.64, i64 4 }, { ptr, i64 } { ptr @tn.str.65, i64 9 }, { ptr, i64 } { ptr @tn.str.66, i64 5 }, { ptr, i64 } { ptr @tn.str.67, i64 12 }, { ptr, i64 } { ptr @tn.str.68, i64 7 }, { ptr, i64 } { ptr @tn.str.69, i64 6 }, { ptr, i64 } { ptr @tn.str.70, i64 10 }, { ptr, i64 } { ptr @tn.str.71, i64 19 }, { ptr, i64 } { ptr @tn.str.72, i64 13 }, { ptr, i64 } { ptr @tn.str.73, i64 5 }, { ptr, i64 } { ptr @tn.str.74, i64 7 }, { ptr, i64 } { ptr @tn.str.75, i64 5 }, { ptr, i64 } { ptr @tn.str.76, i64 3 }, { ptr, i64 } { ptr @tn.str.77, i64 8 }, { ptr, i64 } { ptr @tn.str.78, i64 5 }, { ptr, i64 } { ptr @tn.str.79, i64 8 }, { ptr, i64 } { ptr @tn.str.80, i64 7 }, { ptr, i64 } { ptr @tn.str.81, i64 4 }, { ptr, i64 } { ptr @tn.str.82, i64 6 }]
@str.83 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@str.84 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@str.85 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@str.86 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@str.87 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
@str.88 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
@str.89 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.90 = private unnamed_addr constant [5 x i8] c")); \00", align 1
@str.91 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
@str.92 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
@str.93 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
@str.94 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.95 = private unnamed_addr constant [5 x i8] c")); \00", align 1
@str.96 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
@str.97 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.98 = private unnamed_addr constant [5 x i8] c")); \00", align 1
@str.99 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
@str.100 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.101 = private unnamed_addr constant [5 x i8] c")); \00", align 1
@frame.str = private unnamed_addr constant [21 x i8] c"1009-errors-catch.sx\00"
@frame.str.102 = private unnamed_addr constant [5 x i8] c"must\00"
@frame.str.103 = private unnamed_addr constant [35 x i8] c" if n < 0 { raise error.Bad; }\00"
@trace.frame = private constant { { ptr, i64 }, i32, i32, { ptr, i64 }, { ptr, i64 } } { { ptr, i64 } { ptr @frame.str, i64 20 }, i32 16, i32 17, { ptr, i64 } { ptr @frame.str.102, i64 4 }, { ptr, i64 } { ptr @frame.str.103, i64 34 } }
@frame.str.104 = private unnamed_addr constant [37 x i8] c" if n == 0 { raise error.Empty; }\00"
@trace.frame.105 = private constant { { ptr, i64 }, i32, i32, { ptr, i64 }, { ptr, i64 } } { { ptr, i64 } { ptr @frame.str, i64 20 }, i32 17, i32 17, { ptr, i64 } { ptr @frame.str.102, i64 4 }, { ptr, i64 } { ptr @frame.str.104, i64 36 } }
@frame.str.106 = private unnamed_addr constant [12 x i8] c"handle_some\00"
@frame.str.107 = private unnamed_addr constant [65 x i8] c" raise e; // re-raise the rest\00"
@trace.frame.108 = private constant { { ptr, i64 }, i32, i32, { ptr, i64 }, { ptr, i64 } } { { ptr, i64 } { ptr @frame.str, i64 20 }, i32 46, i32 9, { ptr, i64 } { ptr @frame.str.106, i64 11 }, { ptr, i64 } { ptr @frame.str.107, i64 64 } }
@str.109 = private unnamed_addr constant [18 x i8] c"catch result: {}\0A\00", align 1
@str.110 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@str.111 = private unnamed_addr constant [18 x i8] c"catch result: {}\0A\00", align 1
@str.112 = private unnamed_addr constant [16 x i8] c"Source_Location\00", align 1
@str.113 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.114 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.115 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str = private constant [5 x i8] c"file\00"
@fld.str.116 = private constant [5 x i8] c"line\00"
@fld.str.117 = private constant [4 x i8] c"col\00"
@fld.str.118 = private constant [5 x i8] c"func\00"
@field_names = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str, i64 4 }, { ptr, i64 } { ptr @fld.str.116, i64 4 }, { ptr, i64 } { ptr @fld.str.117, i64 3 }, { ptr, i64 } { ptr @fld.str.118, i64 4 }]
@str.119 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.120 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
@str.121 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.122 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.123 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.124 = private constant [4 x i8] c"ctx\00"
@fld.str.125 = private constant [6 x i8] c"alloc\00"
@fld.str.126 = private constant [8 x i8] c"dealloc\00"
@field_names.127 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.124, i64 3 }, { ptr, i64 } { ptr @fld.str.125, i64 5 }, { ptr, i64 } { ptr @fld.str.126, i64 7 }]
@str.128 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.129 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
@str.130 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.131 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.132 = private unnamed_addr constant [3 x i8] c", \00", align 1
@field_names.133 = private constant [0 x { ptr, i64 }] zeroinitializer
@str.134 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.135 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
@str.136 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.137 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.138 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.139 = private constant [12 x i8] c"alloc_count\00"
@field_names.140 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.139, i64 11 }]
@str.141 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.142 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
@str.143 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.144 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.145 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.146 = private constant [5 x i8] c"next\00"
@fld.str.147 = private constant [4 x i8] c"cap\00"
@field_names.148 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.146, i64 4 }, { ptr, i64 } { ptr @fld.str.147, i64 3 }]
@str.149 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.150 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
@str.151 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.152 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.153 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.154 = private constant [6 x i8] c"first\00"
@fld.str.155 = private constant [10 x i8] c"end_index\00"
@fld.str.156 = private constant [7 x i8] c"parent\00"
@field_names.157 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.154, i64 5 }, { ptr, i64 } { ptr @fld.str.155, i64 9 }, { ptr, i64 } { ptr @fld.str.156, i64 6 }]
@str.158 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.159 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
@str.160 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.161 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.162 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.163 = private constant [4 x i8] c"buf\00"
@fld.str.164 = private constant [4 x i8] c"len\00"
@fld.str.165 = private constant [4 x i8] c"pos\00"
@field_names.166 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.163, i64 3 }, { ptr, i64 } { ptr @fld.str.164, i64 3 }, { ptr, i64 } { ptr @fld.str.165, i64 3 }]
@str.167 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.168 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\00", align 1
@str.169 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.170 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.171 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.172 = private constant [7 x i8] c"parent\00"
@fld.str.173 = private constant [12 x i8] c"alloc_count\00"
@fld.str.174 = private constant [14 x i8] c"dealloc_count\00"
@fld.str.175 = private constant [18 x i8] c"total_alloc_bytes\00"
@field_names.176 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.172, i64 6 }, { ptr, i64 } { ptr @fld.str.173, i64 11 }, { ptr, i64 } { ptr @fld.str.174, i64 13 }, { ptr, i64 } { ptr @fld.str.175, i64 17 }]
@str.177 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.178 = private unnamed_addr constant [8 x i8] c"Context\00", align 1
@str.179 = private unnamed_addr constant [2 x i8] c"{\00", align 1
@str.180 = private unnamed_addr constant [2 x i8] c"}\00", align 1
@str.181 = private unnamed_addr constant [3 x i8] c", \00", align 1
@fld.str.182 = private constant [10 x i8] c"allocator\00"
@fld.str.183 = private constant [5 x i8] c"data\00"
@field_names.184 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.182, i64 9 }, { ptr, i64 } { ptr @fld.str.183, i64 4 }]
@str.185 = private unnamed_addr constant [3 x i8] c": \00", align 1
@str.186 = private unnamed_addr constant [2 x i8] c"[\00", align 1
@str.187 = private unnamed_addr constant [2 x i8] c"]\00", align 1
@str.188 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.189 = private unnamed_addr constant [2 x i8] c"[\00", align 1
@str.190 = private unnamed_addr constant [2 x i8] c"]\00", align 1
@str.191 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.192 = private unnamed_addr constant [2 x i8] c"[\00", align 1
@str.193 = private unnamed_addr constant [2 x i8] c"]\00", align 1
@str.194 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.195 = private unnamed_addr constant [2 x i8] c"[\00", align 1
@str.196 = private unnamed_addr constant [2 x i8] c"]\00", align 1
@str.197 = private unnamed_addr constant [3 x i8] c", \00", align 1
@str.198 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.199 = private unnamed_addr constant [6 x i8] c"*void\00", align 1
@str.200 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.201 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.202 = private unnamed_addr constant [12 x i8] c"*CAllocator\00", align 1
@str.203 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.204 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.205 = private unnamed_addr constant [5 x i8] c"*GPA\00", align 1
@str.206 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.207 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.208 = private unnamed_addr constant [12 x i8] c"*ArenaChunk\00", align 1
@str.209 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.210 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.211 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
@str.212 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.213 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.214 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
@str.215 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.216 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.217 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
@str.218 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.219 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.220 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
@str.221 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.222 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.223 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
@str.224 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.225 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.226 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
@str.227 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.228 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.229 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
@str.230 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.231 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.232 = private unnamed_addr constant [5 x i8] c"*s32\00", align 1
@str.233 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.234 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.235 = private unnamed_addr constant [11 x i8] c"*error_set\00", align 1
@str.236 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.237 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.238 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
@str.239 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.240 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.241 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
@str.242 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.243 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.244 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
@str.245 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.246 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.247 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
@str.248 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.249 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.250 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
@str.251 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
@str.252 = private unnamed_addr constant [5 x i8] c"null\00", align 1
@str.253 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
@str.254 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
; Function Attrs: nounwind
declare void @out(ptr) #0
declare ptr @malloc(i64)
declare void @free(ptr)
declare ptr @memcpy(ptr, ptr, i64)
declare ptr @memset(ptr, i32, i64)
; Function Attrs: nounwind
define internal ptr @CAllocator.alloc(ptr %0, ptr %1, i64 %2) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
store i64 %2, ptr %allocaN, align 8
%load = load i64, ptr %allocaN, align 8
%call = call ptr @malloc(i64 %load)
ret ptr %call
}
; Function Attrs: nounwind
define internal void @CAllocator.dealloc(ptr %0, ptr %1, ptr %2) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca ptr, align 8
store ptr %2, ptr %allocaN, align 8
%load = load ptr, ptr %allocaN, align 8
call void @free(ptr %load)
ret void
}
; Function Attrs: nounwind
declare i64 @GPA.init(ptr) #0
; Function Attrs: nounwind
declare ptr @GPA.alloc(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @GPA.dealloc(ptr, ptr, ptr) #0
; Function Attrs: nounwind
declare void @Arena.add_chunk(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @Arena.init(ptr sret({ ptr, i64, { ptr, ptr, ptr } }), ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @Arena.reset(ptr, ptr) #0
; Function Attrs: nounwind
declare void @Arena.deinit(ptr, ptr) #0
; Function Attrs: nounwind
declare ptr @Arena.alloc(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @Arena.dealloc(ptr, ptr, ptr) #0
; Function Attrs: nounwind
declare ptr @BufAlloc.init(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @BufAlloc.reset(ptr, ptr) #0
; Function Attrs: nounwind
declare ptr @BufAlloc.alloc(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @BufAlloc.dealloc(ptr, ptr, ptr) #0
; Function Attrs: nounwind
declare void @TrackingAllocator.init(ptr sret({ { ptr, ptr, ptr }, i64, i64, i64 }), ptr, ptr) #0
; Function Attrs: nounwind
declare i64 @TrackingAllocator.leak_count(ptr, ptr) #0
; Function Attrs: nounwind
declare void @TrackingAllocator.report(ptr, ptr) #0
; Function Attrs: nounwind
declare ptr @TrackingAllocator.alloc(ptr, ptr, i64) #0
; Function Attrs: nounwind
declare void @TrackingAllocator.dealloc(ptr, ptr, ptr) #0
; Function Attrs: nounwind
define internal { ptr, i64 } @cstring(ptr %0, i64 %1) #0 {
entry:
%alloca = alloca i64, align 8
store i64 %1, ptr %alloca, align 8
%load = load i64, ptr %alloca, align 8
%add = add i64 %load, 1
%loadN = load { { ptr, ptr, ptr }, ptr }, ptr %0, align 8
%sg = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 0
%sgN = extractvalue { ptr, ptr, ptr } %sg, 0
%sgN = extractvalue { ptr, ptr, ptr } %sg, 1
%icall = call ptr %sgN(ptr %0, ptr %sgN, i64 %add)
%allocaN = alloca ptr, align 8
store ptr %icall, ptr %allocaN, align 8
%loadN = load ptr, ptr %allocaN, align 8
%loadN = load i64, ptr %alloca, align 8
%addN = add i64 %loadN, 1
%2 = call ptr @memset(ptr %loadN, i32 0, i64 %addN)
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } undef, ptr %allocaN, align 8
%loadN = load ptr, ptr %allocaN, align 8
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
%pti = ptrtoint ptr %loadN to i64
store i64 %pti, ptr %gep, align 8
%loadN = load i64, ptr %alloca, align 8
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
store i64 %loadN, ptr %gepN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
}
; Function Attrs: nounwind
define internal { ptr, i64 } @int_to_string(ptr %0, i64 %1) #0 {
entry:
%alloca = alloca i64, align 8
%allocaN = alloca i1, align 1
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
store i64 %1, ptr %alloca, align 8
%load = load i64, ptr %alloca, align 8
%icmp = icmp eq i64 %load, 0
br i1 %icmp, label %if.then.44, label %if.merge.45
if.then.44: ; preds = %entry
ret { ptr, i64 } { ptr @str, i64 1 }
if.merge.45: ; preds = %entry
%loadN = load i64, ptr %alloca, align 8
%icmpN = icmp slt i64 %loadN, 0
store i1 %icmpN, ptr %allocaN, align 1
%call = call { ptr, i64 } @cstring(ptr %0, i64 20)
store { ptr, i64 } %call, ptr %allocaN, align 8
store i64 19, ptr %allocaN, align 8
%loadN = load i64, ptr %alloca, align 8
store i64 %loadN, ptr %allocaN, align 8
br label %while.hdr.46
while.hdr.46: ; preds = %if.merge.50, %if.merge.45
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp ne i64 %loadN, 0
br i1 %icmpN, label %while.body.47, label %while.exit.48
while.body.47: ; preds = %while.hdr.46
%loadN = load i64, ptr %allocaN, align 8
%srem = srem i64 %loadN, 10
store i64 %srem, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 0
br i1 %icmpN, label %if.then.49, label %if.merge.50
while.exit.48: ; preds = %while.hdr.46
%loadN = load i1, ptr %allocaN, align 1
br i1 %loadN, label %if.then.51, label %if.merge.52
if.then.49: ; preds = %while.body.47
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 0, %loadN
store i64 %sub, ptr %allocaN, align 8
br label %if.merge.50
if.merge.50: ; preds = %if.then.49, %while.body.47
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 48
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
%trunc = trunc i64 %add to i8
store i8 %trunc, ptr %igp.ptr, align 1
%loadN = load i64, ptr %allocaN, align 8
%sdiv = sdiv i64 %loadN, 10
store i64 %sdiv, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, 1
store i64 %subN, ptr %allocaN, align 8
br label %while.hdr.46
if.then.51: ; preds = %while.exit.48
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data24 = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr25 = getelementptr i8, ptr %igp.data24, i64 %loadN
store i8 45, ptr %igp.ptr25, align 1
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, 1
store i64 %subN, ptr %allocaN, align 8
br label %if.merge.52
if.merge.52: ; preds = %if.then.51, %while.exit.48
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 19, %loadN
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %addN, i64 %subN)
ret { ptr, i64 } %callN
}
; Function Attrs: nounwind
define internal { ptr, i64 } @uint_to_string(ptr %0, i64 %1) #0 {
entry:
%alloca = alloca i64, align 8
%allocaN = alloca [4 x i64], align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca i64, align 8
%ig.tmp = alloca [4 x i64], align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%ig.tmp15 = alloca [4 x i64], align 8
%ig.tmp20 = alloca [4 x i64], align 8
%ig.tmp26 = alloca [4 x i64], align 8
%ig.tmp36 = alloca [4 x i64], align 8
%allocaN = alloca i64, align 8
store i64 %1, ptr %alloca, align 8
%load = load i64, ptr %alloca, align 8
%icmp = icmp eq i64 %load, 0
br i1 %icmp, label %if.then.86, label %if.merge.87
if.then.86: ; preds = %entry
ret { ptr, i64 } { ptr @str.1, i64 1 }
if.merge.87: ; preds = %entry
%loadN = load i64, ptr %alloca, align 8
%call = call [4 x i64] @decompose_u16x4(ptr %0, i64 %loadN)
store [4 x i64] %call, ptr %allocaN, align 8
%callN = call { ptr, i64 } @cstring(ptr %0, i64 20)
store { ptr, i64 } %callN, ptr %allocaN, align 8
store i64 19, ptr %allocaN, align 8
br label %while.hdr.96
while.hdr.96: ; preds = %while.exit.107, %if.merge.87
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp, align 8
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 0
%ig.val = load i64, ptr %ig.ptr, align 8
%icmpN = icmp ne i64 %ig.val, 0
br i1 %icmpN, label %or.merge.100, label %or.rhs.99
while.body.97: ; preds = %or.merge.104
store i64 0, ptr %allocaN, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.105
while.exit.98: ; preds = %or.merge.104
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 19, %loadN
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %add, i64 %sub)
ret { ptr, i64 } %callN
or.rhs.99: ; preds = %while.hdr.96
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp15, align 8
%ig.ptr16 = getelementptr [4 x i64], ptr %ig.tmp15, i64 0, i64 1
%ig.val17 = load i64, ptr %ig.ptr16, align 8
%icmpN = icmp ne i64 %ig.val17, 0
br label %or.merge.100
or.merge.100: ; preds = %or.rhs.99, %while.hdr.96
%bp = phi i1 [ true, %while.hdr.96 ], [ %icmpN, %or.rhs.99 ]
br i1 %bp, label %or.merge.102, label %or.rhs.101
or.rhs.101: ; preds = %or.merge.100
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp20, align 8
%ig.ptr21 = getelementptr [4 x i64], ptr %ig.tmp20, i64 0, i64 2
%ig.val22 = load i64, ptr %ig.ptr21, align 8
%icmpN = icmp ne i64 %ig.val22, 0
br label %or.merge.102
or.merge.102: ; preds = %or.rhs.101, %or.merge.100
%bpN = phi i1 [ true, %or.merge.100 ], [ %icmpN, %or.rhs.101 ]
br i1 %bpN, label %or.merge.104, label %or.rhs.103
or.rhs.103: ; preds = %or.merge.102
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp26, align 8
%ig.ptr27 = getelementptr [4 x i64], ptr %ig.tmp26, i64 0, i64 3
%ig.val28 = load i64, ptr %ig.ptr27, align 8
%icmpN = icmp ne i64 %ig.val28, 0
br label %or.merge.104
or.merge.104: ; preds = %or.rhs.103, %or.merge.102
%bpN = phi i1 [ true, %or.merge.102 ], [ %icmpN, %or.rhs.103 ]
br i1 %bpN, label %while.body.97, label %while.exit.98
while.hdr.105: ; preds = %while.body.106, %while.body.97
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 4
br i1 %icmpN, label %while.body.106, label %while.exit.107
while.body.106: ; preds = %while.hdr.105
%loadN = load i64, ptr %allocaN, align 8
%mul = mul i64 %loadN, 65536
%loadN = load [4 x i64], ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp36, align 8
%ig.ptr37 = getelementptr [4 x i64], ptr %ig.tmp36, i64 0, i64 %loadN
%ig.val38 = load i64, ptr %ig.ptr37, align 8
%addN = add i64 %mul, %ig.val38
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sdiv = sdiv i64 %loadN, 10
%loadN = load i64, ptr %allocaN, align 8
%igp.ptr = getelementptr i64, ptr %allocaN, i64 %loadN
store i64 %sdiv, ptr %igp.ptr, align 8
%loadN = load i64, ptr %allocaN, align 8
%srem = srem i64 %loadN, 10
store i64 %srem, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %while.hdr.105
while.exit.107: ; preds = %while.hdr.105
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 48
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr50 = getelementptr i8, ptr %igp.data, i64 %loadN
%trunc = trunc i64 %addN to i8
store i8 %trunc, ptr %igp.ptr50, align 1
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, 1
store i64 %subN, ptr %allocaN, align 8
br label %while.hdr.96
}
; Function Attrs: nounwind
define internal { ptr, i64 } @bool_to_string(ptr %0, i1 %1) #0 {
entry:
%alloca = alloca i1, align 1
store i1 %1, ptr %alloca, align 1
%load = load i1, ptr %alloca, align 1
br i1 %load, label %if.then.108, label %if.else.109
if.then.108: ; preds = %entry
br label %if.merge.110
if.else.109: ; preds = %entry
br label %if.merge.110
if.merge.110: ; preds = %if.else.109, %if.then.108
%bp = phi { ptr, i64 } [ { ptr @str.2, i64 4 }, %if.then.108 ], [ { ptr @str.3, i64 5 }, %if.else.109 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @float_to_string(ptr %0, double %1) #0 {
entry:
%alloca = alloca double, align 8
%allocaN = alloca double, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
store double %1, ptr %alloca, align 8
%load = load double, ptr %alloca, align 8
%fcmp = fcmp olt double %load, 0.000000e+00
%allocaN = alloca i1, align 1
store i1 %fcmp, ptr %allocaN, align 1
%loadN = load i1, ptr %allocaN, align 1
br i1 %loadN, label %if.then.114, label %if.else.115
if.then.114: ; preds = %entry
%loadN = load double, ptr %alloca, align 8
%fsub = fsub double 0.000000e+00, %loadN
br label %if.merge.116
if.else.115: ; preds = %entry
%loadN = load double, ptr %alloca, align 8
br label %if.merge.116
if.merge.116: ; preds = %if.else.115, %if.then.114
%bp = phi double [ %fsub, %if.then.114 ], [ %loadN, %if.else.115 ]
store double %bp, ptr %allocaN, align 8
%loadN = load double, ptr %allocaN, align 8
%fptosi = fptosi double %loadN to i64
store i64 %fptosi, ptr %allocaN, align 8
%loadN = load double, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sitofp = sitofp i64 %loadN to double
%fsubN = fsub double %loadN, %sitofp
%fmul = fmul double %fsubN, 1.000000e+06
%fptosiN = fptosi double %fmul to i64
store i64 %fptosiN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %loadN, 0
br i1 %icmp, label %if.then.117, label %if.merge.118
if.then.117: ; preds = %if.merge.116
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 0, %loadN
store i64 %sub, ptr %allocaN, align 8
br label %if.merge.118
if.merge.118: ; preds = %if.then.117, %if.merge.116
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
store { ptr, i64 } %call, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%len = extractvalue { ptr, i64 } %loadN, 1
store i64 %len, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
store i64 %lenN, ptr %allocaN, align 8
%loadN = load i1, ptr %allocaN, align 1
br i1 %loadN, label %if.then.119, label %if.else.120
if.then.119: ; preds = %if.merge.118
br label %if.merge.121
if.else.120: ; preds = %if.merge.118
br label %if.merge.121
if.merge.121: ; preds = %if.else.120, %if.then.119
%bpN = phi i64 [ 1, %if.then.119 ], [ 0, %if.else.120 ]
store i64 %bpN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, %loadN
%addN = add i64 %add, 1
%addN = add i64 %addN, 6
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @cstring(ptr %0, i64 %loadN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
store i64 0, ptr %allocaN, align 8
%loadN = load i1, ptr %allocaN, align 1
br i1 %loadN, label %if.then.122, label %if.merge.123
if.then.122: ; preds = %if.merge.121
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr = getelementptr i8, ptr %igp.data, i64 0
store i8 45, ptr %igp.ptr, align 1
store i64 1, ptr %allocaN, align 8
br label %if.merge.123
if.merge.123: ; preds = %if.then.122, %if.merge.121
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data41 = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr42 = getelementptr i8, ptr %igp.data41, i64 %loadN
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%dptr = extractvalue { ptr, i64 } %loadN, 0
%loadN = load i64, ptr %allocaN, align 8
%callN = call ptr @memcpy(ptr %igp.ptr42, ptr %dptr, i64 %loadN)
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, %loadN
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data51 = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr52 = getelementptr i8, ptr %igp.data51, i64 %loadN
store i8 46, ptr %igp.ptr52, align 1
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 6, %loadN
store i64 %subN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data60 = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr61 = getelementptr i8, ptr %igp.data60, i64 %loadN
%loadN = load i64, ptr %allocaN, align 8
%2 = call ptr @memset(ptr %igp.ptr61, i32 48, i64 %loadN)
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, %loadN
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data68 = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr69 = getelementptr i8, ptr %igp.data68, i64 %loadN
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%dptrN = extractvalue { ptr, i64 } %loadN, 0
%loadN = load i64, ptr %allocaN, align 8
%callN = call ptr @memcpy(ptr %igp.ptr69, ptr %dptrN, i64 %loadN)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
}
; Function Attrs: nounwind
define internal void @hex_group(ptr %0, { ptr, i64 } %1, i64 %2, i64 %3) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
%allocaN = alloca i64, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
store i64 %2, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 %3, ptr %allocaN, align 8
%load = load i64, ptr %allocaN, align 8
%add = add i64 %load, 3
%allocaN = alloca i64, align 8
store i64 %add, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 %loadN, ptr %allocaN, align 8
br label %while.hdr.234
while.hdr.234: ; preds = %if.merge.239, %entry
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp sge i64 %loadN, %loadN
br i1 %icmp, label %while.body.235, label %while.exit.236
while.body.235: ; preds = %while.hdr.234
%loadN = load i64, ptr %allocaN, align 8
%srem = srem i64 %loadN, 16
store i64 %srem, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 10
br i1 %icmpN, label %if.then.237, label %if.else.238
while.exit.236: ; preds = %while.hdr.234
ret void
if.then.237: ; preds = %while.body.235
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 48
br label %if.merge.239
if.else.238: ; preds = %while.body.235
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 %loadN, 10
%addN = add i64 %sub, 97
br label %if.merge.239
if.merge.239: ; preds = %if.else.238, %if.then.237
%bp = phi i64 [ %addN, %if.then.237 ], [ %addN, %if.else.238 ]
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
%trunc = trunc i64 %bp to i8
store i8 %trunc, ptr %igp.ptr, align 1
%loadN = load i64, ptr %allocaN, align 8
%sdiv = sdiv i64 %loadN, 16
store i64 %sdiv, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, 1
store i64 %subN, ptr %allocaN, align 8
br label %while.hdr.234
}
; Function Attrs: nounwind
define internal [4 x i64] @decompose_u16x4(ptr %0, i64 %1) #0 {
entry:
%alloca = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca i64, align 8
%allocaN = alloca [4 x i64], align 8
store i64 %1, ptr %alloca, align 8
%load = load i64, ptr %alloca, align 8
%srem = srem i64 %load, 65536
%allocaN = alloca i64, align 8
store i64 %srem, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %loadN, 0
br i1 %icmp, label %if.then.88, label %if.merge.89
if.then.88: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 65536
store i64 %add, ptr %allocaN, align 8
br label %if.merge.89
if.merge.89: ; preds = %if.then.88, %entry
%loadN = load i64, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 %loadN, %loadN
%sdiv = sdiv i64 %sub, 65536
store i64 %sdiv, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sremN = srem i64 %loadN, 65536
store i64 %sremN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 0
br i1 %icmpN, label %if.then.90, label %if.merge.91
if.then.90: ; preds = %if.merge.89
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 65536
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.91
if.merge.91: ; preds = %if.then.90, %if.merge.89
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, %loadN
%sdivN = sdiv i64 %subN, 65536
store i64 %sdivN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sremN = srem i64 %loadN, 65536
store i64 %sremN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 0
br i1 %icmpN, label %if.then.92, label %if.merge.93
if.then.92: ; preds = %if.merge.91
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 65536
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.93
if.merge.93: ; preds = %if.then.92, %if.merge.91
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, %loadN
%sdivN = sdiv i64 %subN, 65536
store i64 %sdivN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sremN = srem i64 %loadN, 65536
store i64 %sremN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 0
br i1 %icmpN, label %if.then.94, label %if.merge.95
if.then.94: ; preds = %if.merge.93
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 65536
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.95
if.merge.95: ; preds = %if.then.94, %if.merge.93
store [4 x i64] undef, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%igp.ptr = getelementptr i64, ptr %allocaN, i64 0
store i64 %loadN, ptr %igp.ptr, align 8
%loadN = load i64, ptr %allocaN, align 8
%igp.ptr41 = getelementptr i64, ptr %allocaN, i64 1
store i64 %loadN, ptr %igp.ptr41, align 8
%loadN = load i64, ptr %allocaN, align 8
%igp.ptr43 = getelementptr i64, ptr %allocaN, i64 2
store i64 %loadN, ptr %igp.ptr43, align 8
%loadN = load i64, ptr %allocaN, align 8
%igp.ptr45 = getelementptr i64, ptr %allocaN, i64 3
store i64 %loadN, ptr %igp.ptr45, align 8
%loadN = load [4 x i64], ptr %allocaN, align 8
ret [4 x i64] %loadN
}
; Function Attrs: nounwind
define internal { ptr, i64 } @int_to_hex_string(ptr %0, i64 %1) #0 {
entry:
%alloca = alloca i64, align 8
%allocaN = alloca [4 x i64], align 8
%allocaN = alloca { ptr, i64 }, align 8
%ig.tmp = alloca [4 x i64], align 8
%ig.tmp9 = alloca [4 x i64], align 8
%ig.tmp14 = alloca [4 x i64], align 8
%ig.tmp19 = alloca [4 x i64], align 8
%allocaN = alloca i64, align 8
store i64 %1, ptr %alloca, align 8
%load = load i64, ptr %alloca, align 8
%icmp = icmp eq i64 %load, 0
br i1 %icmp, label %if.then.232, label %if.merge.233
if.then.232: ; preds = %entry
ret { ptr, i64 } { ptr @str.4, i64 1 }
if.merge.233: ; preds = %entry
%loadN = load i64, ptr %alloca, align 8
%call = call [4 x i64] @decompose_u16x4(ptr %0, i64 %loadN)
store [4 x i64] %call, ptr %allocaN, align 8
%callN = call { ptr, i64 } @cstring(ptr %0, i64 16)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp, align 8
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 0
%ig.val = load i64, ptr %ig.ptr, align 8
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 0, i64 %ig.val)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp9, align 8
%ig.ptr10 = getelementptr [4 x i64], ptr %ig.tmp9, i64 0, i64 1
%ig.val11 = load i64, ptr %ig.ptr10, align 8
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 4, i64 %ig.val11)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp14, align 8
%ig.ptr15 = getelementptr [4 x i64], ptr %ig.tmp14, i64 0, i64 2
%ig.val16 = load i64, ptr %ig.ptr15, align 8
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 8, i64 %ig.val16)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [4 x i64], ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp19, align 8
%ig.ptr20 = getelementptr [4 x i64], ptr %ig.tmp19, i64 0, i64 3
%ig.val21 = load i64, ptr %ig.ptr20, align 8
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 12, i64 %ig.val21)
store i64 0, ptr %allocaN, align 8
br label %while.hdr.240
while.hdr.240: ; preds = %if.merge.244, %if.merge.233
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp slt i64 %loadN, 15
br i1 %icmpN, label %while.body.241, label %while.exit.242
while.body.241: ; preds = %while.hdr.240
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%ig.data = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr27 = getelementptr i8, ptr %ig.data, i64 %loadN
%ig.val28 = load i8, ptr %ig.ptr27, align 1
%cmp.ext = zext i8 %ig.val28 to i64
%icmpN = icmp ne i64 %cmp.ext, 48
br i1 %icmpN, label %if.then.243, label %if.merge.244
while.exit.242: ; preds = %if.then.243, %while.hdr.240
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 16, %loadN
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %loadN, i64 %sub)
ret { ptr, i64 } %callN
if.then.243: ; preds = %while.body.241
br label %while.exit.242
if.merge.244: ; preds = %while.body.241
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.240
}
; Function Attrs: nounwind
define internal { ptr, i64 } @concat(ptr %0, { ptr, i64 } %1, { ptr, i64 } %2) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %2, ptr %allocaN, align 8
%load = load { ptr, i64 }, ptr %alloca, align 8
%len = extractvalue { ptr, i64 } %load, 1
%allocaN = alloca i64, align 8
store i64 %len, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
%allocaN = alloca i64, align 8
store i64 %lenN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, %loadN
%call = call { ptr, i64 } @cstring(ptr %0, i64 %add)
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%dptr = extractvalue { ptr, i64 } %loadN, 0
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%dptrN = extractvalue { ptr, i64 } %loadN, 0
%loadN = load i64, ptr %allocaN, align 8
%callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%dptrN = extractvalue { ptr, i64 } %loadN, 0
%loadN = load i64, ptr %allocaN, align 8
%callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
}
; Function Attrs: nounwind
define internal { ptr, i64 } @substr(ptr %0, { ptr, i64 } %1, i64 %2, i64 %3) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
store i64 %2, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 %3, ptr %allocaN, align 8
%load = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @cstring(ptr %0, i64 %load)
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%dptr = extractvalue { ptr, i64 } %loadN, 0
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%igp.data = extractvalue { ptr, i64 } %loadN, 0
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
%loadN = load i64, ptr %allocaN, align 8
%callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
}
; Function Attrs: nounwind
declare ptr @xml_escape(ptr, ptr) #0
; Function Attrs: nounwind
declare ptr @path_join(ptr, ptr) #0
; Function Attrs: nounwind
define internal { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %1) #0 {
entry:
%alloca = alloca { i64, i64 }, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca double, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca i32, align 4
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca { ptr, i64 }, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { i64, i64 } %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.5, i64 3 }, ptr %allocaN, align 8
%load = load { i64, i64 }, ptr %alloca, align 8
%sg = extractvalue { i64, i64 } %load, 0
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %sg, 1
%allocaN = alloca { i64, i64 }, align 8
store { i64, i64 } %ba.val, ptr %allocaN, align 8
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%ua.raw = extractvalue { i64, i64 } %loadN, 1
switch i64 %ua.raw, label %match.unr.82 [
i64 17, label %match.arm.68
i64 2, label %match.arm.69
i64 3, label %match.arm.69
i64 4, label %match.arm.69
i64 5, label %match.arm.69
i64 6, label %match.arm.69
i64 7, label %match.arm.69
i64 8, label %match.arm.69
i64 9, label %match.arm.69
i64 16, label %match.arm.69
i64 15, label %match.arm.69
i64 12, label %match.arm.70
i64 1, label %match.arm.71
i64 10, label %match.arm.72
i64 11, label %match.arm.72
i64 19, label %match.arm.73
i64 20, label %match.arm.73
i64 21, label %match.arm.73
i64 23, label %match.arm.73
i64 25, label %match.arm.73
i64 27, label %match.arm.73
i64 30, label %match.arm.73
i64 32, label %match.arm.73
i64 34, label %match.arm.73
i64 37, label %match.arm.75
i64 35, label %match.arm.77
i64 46, label %match.arm.77
i64 36, label %match.arm.78
i64 44, label %match.arm.78
i64 18, label %match.arm.79
i64 22, label %match.arm.79
i64 24, label %match.arm.79
i64 26, label %match.arm.79
i64 28, label %match.arm.79
i64 29, label %match.arm.79
i64 31, label %match.arm.79
i64 33, label %match.arm.79
i64 38, label %match.arm.79
i64 39, label %match.arm.79
i64 40, label %match.arm.79
i64 41, label %match.arm.79
i64 42, label %match.arm.79
i64 43, label %match.arm.79
i64 45, label %match.arm.79
i64 47, label %match.arm.79
i64 48, label %match.arm.79
i64 49, label %match.arm.79
i64 50, label %match.arm.79
i64 13, label %match.arm.81
]
match.merge.67: ; preds = %dispatch.merge.208, %dispatch.merge.194, %dispatch.merge.180, %dispatch.merge.124, %float.merge.113, %if.merge.85, %match.unr.82, %match.arm.81, %match.arm.75, %match.arm.71, %match.arm.70, %match.arm.68
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
match.arm.68: ; preds = %entry
store { ptr, i64 } { ptr @str.6, i64 0 }, ptr %allocaN, align 8
br label %match.merge.67
match.arm.69: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%refl.tag = extractvalue { i64, i64 } %loadN, 0
%refl.val = extractvalue { i64, i64 } %loadN, 1
%refl.istype = icmp eq i64 %refl.tag, 13
%refl.tid = select i1 %refl.istype, i64 %refl.val, i64 %refl.tag
%tiu.gep = getelementptr inbounds [75 x i1], ptr @__sx_type_is_unsigned, i64 0, i64 %refl.tid
%tiu.load = load i1, ptr %tiu.gep, align 1
br i1 %tiu.load, label %if.then.83, label %if.else.84
match.arm.70: ; preds = %entry
%loadN = load { i64, i64 }, ptr %alloca, align 8
%ua.raw8 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr = inttoptr i64 %ua.raw8 to ptr
%ua.load = load { ptr, i64 }, ptr %ua.ptr, align 8
store { ptr, i64 } %ua.load, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
store { ptr, i64 } %loadN, ptr %allocaN, align 8
br label %match.merge.67
match.arm.71: ; preds = %entry
%loadN = load { i64, i64 }, ptr %alloca, align 8
%ua.raw11 = extractvalue { i64, i64 } %loadN, 1
%tr = trunc i64 %ua.raw11 to i1
%call = call { ptr, i64 } @bool_to_string(ptr %0, i1 %tr)
store { ptr, i64 } %call, ptr %allocaN, align 8
br label %match.merge.67
match.arm.72: ; preds = %entry, %entry
%loadN = load { i64, i64 }, ptr %alloca, align 8
%sgN = extractvalue { i64, i64 } %loadN, 0
%icmp = icmp eq i64 %sgN, 10
br i1 %icmp, label %fN.unbox.111, label %fN.unbox.112
match.arm.73: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%ua.raw16 = extractvalue { i64, i64 } %loadN, 1
%loadN = load { i64, i64 }, ptr %alloca, align 8
switch i64 %ua.raw16, label %dispatch.default.125 [
i64 19, label %dispatch.case.126
i64 20, label %dispatch.case.127
i64 21, label %dispatch.case.128
i64 23, label %dispatch.case.129
i64 25, label %dispatch.case.130
i64 27, label %dispatch.case.131
i64 30, label %dispatch.case.132
i64 32, label %dispatch.case.133
i64 34, label %dispatch.case.134
]
match.arm.74: ; No predecessors!
unreachable
match.arm.75: ; preds = %entry
%loadN = load { i64, i64 }, ptr %alloca, align 8
%ua.raw21 = extractvalue { i64, i64 } %loadN, 1
%trN = trunc i64 %ua.raw21 to i32
store i32 %trN, ptr %allocaN, align 4
%loadN = load i32, ptr %allocaN, align 4
%etn.idx = zext i32 %loadN to i64
%etn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @tag_names, i64 0, i64 %etn.idx
%etn.load = load { ptr, i64 }, ptr %etn.gep, align 8
store { ptr, i64 } %etn.load, ptr %allocaN, align 8
br label %match.merge.67
match.arm.76: ; No predecessors!
unreachable
match.arm.77: ; preds = %entry, %entry
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%ua.raw25 = extractvalue { i64, i64 } %loadN, 1
%loadN = load { i64, i64 }, ptr %alloca, align 8
switch i64 %ua.raw25, label %dispatch.default.181 [
i64 35, label %dispatch.case.182
i64 46, label %dispatch.case.183
]
match.arm.78: ; preds = %entry, %entry
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%ua.raw29 = extractvalue { i64, i64 } %loadN, 1
%loadN = load { i64, i64 }, ptr %alloca, align 8
switch i64 %ua.raw29, label %dispatch.default.195 [
i64 36, label %dispatch.case.196
i64 44, label %dispatch.case.197
]
match.arm.79: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
%loadN = load { i64, i64 }, ptr %allocaN, align 8
%ua.raw33 = extractvalue { i64, i64 } %loadN, 1
%loadN = load { i64, i64 }, ptr %alloca, align 8
switch i64 %ua.raw33, label %dispatch.default.209 [
i64 18, label %dispatch.case.210
i64 22, label %dispatch.case.211
i64 24, label %dispatch.case.212
i64 26, label %dispatch.case.213
i64 28, label %dispatch.case.214
i64 29, label %dispatch.case.215
i64 31, label %dispatch.case.216
i64 33, label %dispatch.case.217
i64 38, label %dispatch.case.218
i64 39, label %dispatch.case.219
i64 40, label %dispatch.case.220
i64 41, label %dispatch.case.221
i64 42, label %dispatch.case.222
i64 43, label %dispatch.case.223
i64 45, label %dispatch.case.224
i64 47, label %dispatch.case.225
i64 48, label %dispatch.case.226
i64 49, label %dispatch.case.227
i64 50, label %dispatch.case.228
]
match.arm.80: ; No predecessors!
unreachable
match.arm.81: ; preds = %entry
%loadN = load { i64, i64 }, ptr %alloca, align 8
%refl.tag37 = extractvalue { i64, i64 } %loadN, 0
%refl.val38 = extractvalue { i64, i64 } %loadN, 1
%refl.istype39 = icmp eq i64 %refl.tag37, 13
%refl.tid40 = select i1 %refl.istype39, i64 %refl.val38, i64 %refl.tag37
%tn.gep = getelementptr inbounds [75 x { ptr, i64 }], ptr @__sx_type_names, i64 0, i64 %refl.tid40
%tn.load = load { ptr, i64 }, ptr %tn.gep, align 8
store { ptr, i64 } %tn.load, ptr %allocaN, align 8
br label %match.merge.67
match.unr.82: ; preds = %entry
br label %match.merge.67
if.then.83: ; preds = %match.arm.69
%loadN = load { i64, i64 }, ptr %alloca, align 8
%ua.raw42 = extractvalue { i64, i64 } %loadN, 1
%callN = call { ptr, i64 } @uint_to_string(ptr %0, i64 %ua.raw42)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.85
if.else.84: ; preds = %match.arm.69
%loadN = load { i64, i64 }, ptr %alloca, align 8
%ua.raw45 = extractvalue { i64, i64 } %loadN, 1
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %ua.raw45)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.85
if.merge.85: ; preds = %if.else.84, %if.then.83
br label %match.merge.67
f32.unbox.111: ; preds = %match.arm.72
%ua.raw47 = extractvalue { i64, i64 } %loadN, 1
%trN = trunc i64 %ua.raw47 to i32
%iNf = bitcast i32 %trN to float
%fpext = fpext float %iNf to double
store double %fpext, ptr %allocaN, align 8
br label %float.merge.113
f64.unbox.112: ; preds = %match.arm.72
%ua.raw48 = extractvalue { i64, i64 } %loadN, 1
%iNd = bitcast i64 %ua.raw48 to double
store double %iNd, ptr %allocaN, align 8
br label %float.merge.113
float.merge.113: ; preds = %fN.unbox.112, %fN.unbox.111
%loadN = load double, ptr %allocaN, align 8
%callN = call { ptr, i64 } @float_to_string(ptr %0, double %loadN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %match.merge.67
dispatch.merge.124: ; preds = %dispatch.case.134, %dispatch.case.133, %dispatch.case.132, %dispatch.case.131, %dispatch.case.130, %dispatch.case.129, %dispatch.case.128, %dispatch.case.127, %dispatch.case.126, %dispatch.default.125
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
store { ptr, i64 } %loadN, ptr %allocaN, align 8
br label %match.merge.67
dispatch.default.125: ; preds = %match.arm.73
store { ptr, i64 } { ptr @str.83, i64 0 }, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.126: ; preds = %match.arm.73
%ua.raw52 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr53 = inttoptr i64 %ua.raw52 to ptr
%ua.load54 = load { { ptr, i64 }, i32, i32, { ptr, i64 } }, ptr %ua.ptr53, align 8
%callN = call { ptr, i64 } @struct_to_string__Source_Location(ptr %0, { { ptr, i64 }, i32, i32, { ptr, i64 } } %ua.load54)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.127: ; preds = %match.arm.73
%ua.raw56 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr57 = inttoptr i64 %ua.raw56 to ptr
%ua.load58 = load { ptr, ptr, ptr }, ptr %ua.ptr57, align 8
%callN = call { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %ua.load58)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.128: ; preds = %match.arm.73
%ua.raw60 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr61 = inttoptr i64 %ua.raw60 to ptr
%ua.load62 = load {}, ptr %ua.ptr61, align 1
%callN = call { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %ua.load62)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.129: ; preds = %match.arm.73
%ua.raw64 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr65 = inttoptr i64 %ua.raw64 to ptr
%ua.load66 = load { i64 }, ptr %ua.ptr65, align 8
%callN = call { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %ua.load66)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.130: ; preds = %match.arm.73
%ua.raw68 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr69 = inttoptr i64 %ua.raw68 to ptr
%ua.load70 = load { ptr, i64 }, ptr %ua.ptr69, align 8
%callN = call { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %ua.load70)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.131: ; preds = %match.arm.73
%ua.raw72 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr73 = inttoptr i64 %ua.raw72 to ptr
%ua.load74 = load { ptr, i64, { ptr, ptr, ptr } }, ptr %ua.ptr73, align 8
%callN = call { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %ua.load74)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.132: ; preds = %match.arm.73
%ua.raw76 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr77 = inttoptr i64 %ua.raw76 to ptr
%ua.load78 = load { ptr, i64, i64 }, ptr %ua.ptr77, align 8
%callN = call { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %ua.load78)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.133: ; preds = %match.arm.73
%ua.raw80 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr81 = inttoptr i64 %ua.raw80 to ptr
%ua.load82 = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %ua.ptr81, align 8
%callN = call { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %ua.load82)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.case.134: ; preds = %match.arm.73
%ua.raw84 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr85 = inttoptr i64 %ua.raw84 to ptr
%ua.load86 = load { { ptr, ptr, ptr }, ptr }, ptr %ua.ptr85, align 8
%callN = call { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %ua.load86)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.124
dispatch.merge.180: ; preds = %dispatch.case.183, %dispatch.case.182, %dispatch.default.181
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
store { ptr, i64 } %loadN, ptr %allocaN, align 8
br label %match.merge.67
dispatch.default.181: ; preds = %match.arm.77
store { ptr, i64 } { ptr @str.84, i64 0 }, ptr %allocaN, align 8
br label %dispatch.merge.180
dispatch.case.182: ; preds = %match.arm.77
%ua.raw89 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr90 = inttoptr i64 %ua.raw89 to ptr
%ua.load91 = load [4 x i64], ptr %ua.ptr90, align 8
%callN = call { ptr, i64 } @array_to_string__AR_4_s64(ptr %0, [4 x i64] %ua.load91)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.180
dispatch.case.183: ; preds = %match.arm.77
%ua.raw93 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr94 = inttoptr i64 %ua.raw93 to ptr
%ua.load95 = load [1 x { i64, i64 }], ptr %ua.ptr94, align 8
%callN = call { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %ua.load95)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.180
dispatch.merge.194: ; preds = %dispatch.case.197, %dispatch.case.196, %dispatch.default.195
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
store { ptr, i64 } %loadN, ptr %allocaN, align 8
br label %match.merge.67
dispatch.default.195: ; preds = %match.arm.78
store { ptr, i64 } { ptr @str.85, i64 0 }, ptr %allocaN, align 8
br label %dispatch.merge.194
dispatch.case.196: ; preds = %match.arm.78
%ua.raw98 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr99 = inttoptr i64 %ua.raw98 to ptr
%ua.load100 = load { ptr, i64 }, ptr %ua.ptr99, align 8
%callN = call { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %ua.load100)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.194
dispatch.case.197: ; preds = %match.arm.78
%ua.raw102 = extractvalue { i64, i64 } %loadN, 1
%ua.ptr103 = inttoptr i64 %ua.raw102 to ptr
%ua.load104 = load { ptr, i64 }, ptr %ua.ptr103, align 8
%callN = call { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %ua.load104)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.194
dispatch.merge.208: ; preds = %dispatch.case.228, %dispatch.case.227, %dispatch.case.226, %dispatch.case.225, %dispatch.case.224, %dispatch.case.223, %dispatch.case.222, %dispatch.case.221, %dispatch.case.220, %dispatch.case.219, %dispatch.case.218, %dispatch.case.217, %dispatch.case.216, %dispatch.case.215, %dispatch.case.214, %dispatch.case.213, %dispatch.case.212, %dispatch.case.211, %dispatch.case.210, %dispatch.default.209
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
store { ptr, i64 } %loadN, ptr %allocaN, align 8
br label %match.merge.67
dispatch.default.209: ; preds = %match.arm.79
store { ptr, i64 } { ptr @str.86, i64 0 }, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.210: ; preds = %match.arm.79
%ua.raw107 = extractvalue { i64, i64 } %loadN, 1
%iNp = inttoptr i64 %ua.raw107 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_void(ptr %0, ptr %iNp)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.211: ; preds = %match.arm.79
%ua.raw109 = extractvalue { i64, i64 } %loadN, 1
%iNp110 = inttoptr i64 %ua.raw109 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %iNp110)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.212: ; preds = %match.arm.79
%ua.raw112 = extractvalue { i64, i64 } %loadN, 1
%iNp113 = inttoptr i64 %ua.raw112 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %iNp113)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.213: ; preds = %match.arm.79
%ua.raw115 = extractvalue { i64, i64 } %loadN, 1
%iNp116 = inttoptr i64 %ua.raw115 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %iNp116)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.214: ; preds = %match.arm.79
%ua.raw118 = extractvalue { i64, i64 } %loadN, 1
%iNp119 = inttoptr i64 %ua.raw118 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %iNp119)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.215: ; preds = %match.arm.79
%ua.raw121 = extractvalue { i64, i64 } %loadN, 1
%iNp122 = inttoptr i64 %ua.raw121 to ptr
%callN = call { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %iNp122)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.216: ; preds = %match.arm.79
%ua.raw124 = extractvalue { i64, i64 } %loadN, 1
%iNp125 = inttoptr i64 %ua.raw124 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %iNp125)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.217: ; preds = %match.arm.79
%ua.raw127 = extractvalue { i64, i64 } %loadN, 1
%iNp128 = inttoptr i64 %ua.raw127 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %iNp128)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.218: ; preds = %match.arm.79
%ua.raw130 = extractvalue { i64, i64 } %loadN, 1
%iNp131 = inttoptr i64 %ua.raw130 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %iNp131)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.219: ; preds = %match.arm.79
%ua.raw133 = extractvalue { i64, i64 } %loadN, 1
%iNp134 = inttoptr i64 %ua.raw133 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %iNp134)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.220: ; preds = %match.arm.79
%ua.raw136 = extractvalue { i64, i64 } %loadN, 1
%iNp137 = inttoptr i64 %ua.raw136 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %iNp137)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.221: ; preds = %match.arm.79
%ua.raw139 = extractvalue { i64, i64 } %loadN, 1
%iNp140 = inttoptr i64 %ua.raw139 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_s32(ptr %0, ptr %iNp140)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.222: ; preds = %match.arm.79
%ua.raw142 = extractvalue { i64, i64 } %loadN, 1
%iNp143 = inttoptr i64 %ua.raw142 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_error_set(ptr %0, ptr %iNp143)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.223: ; preds = %match.arm.79
%ua.raw145 = extractvalue { i64, i64 } %loadN, 1
%iNp146 = inttoptr i64 %ua.raw145 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp146)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.224: ; preds = %match.arm.79
%ua.raw148 = extractvalue { i64, i64 } %loadN, 1
%iNp149 = inttoptr i64 %ua.raw148 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp149)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.225: ; preds = %match.arm.79
%ua.raw151 = extractvalue { i64, i64 } %loadN, 1
%iNp152 = inttoptr i64 %ua.raw151 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp152)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.226: ; preds = %match.arm.79
%ua.raw154 = extractvalue { i64, i64 } %loadN, 1
%iNp155 = inttoptr i64 %ua.raw154 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp155)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.227: ; preds = %match.arm.79
%ua.raw157 = extractvalue { i64, i64 } %loadN, 1
%iNp158 = inttoptr i64 %ua.raw157 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp158)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
dispatch.case.228: ; preds = %match.arm.79
%ua.raw160 = extractvalue { i64, i64 } %loadN, 1
%iNp161 = inttoptr i64 %ua.raw160 to ptr
%callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp161)
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %dispatch.merge.208
}
; Function Attrs: nounwind
define internal { ptr, i64 } @build_format(ptr %0, { ptr, i64 } %1) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.87, i64 14 }, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.30
while.hdr.30: ; preds = %if.merge.35, %entry
%load = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%len = extractvalue { ptr, i64 } %loadN, 1
%icmp = icmp slt i64 %load, %len
br i1 %icmp, label %while.body.31, label %while.exit.32
while.body.31: ; preds = %while.hdr.30
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%ig.data = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr = getelementptr i8, ptr %ig.data, i64 %loadN
%ig.val = load i8, ptr %ig.ptr, align 1
%cmp.ext = zext i8 %ig.val to i64
%icmpN = icmp eq i64 %cmp.ext, 123
br i1 %icmpN, label %if.then.33, label %if.else.34
while.exit.32: ; preds = %while.hdr.30
%loadN = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
%icmpN = icmp slt i64 %loadN, %lenN
br i1 %icmpN, label %if.then.65, label %if.merge.66
if.then.33: ; preds = %while.body.31
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
%icmpN = icmp slt i64 %add, %lenN
br i1 %icmpN, label %if.then.36, label %if.else.37
if.else.34: ; preds = %while.body.31
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%ig.data19 = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr20 = getelementptr i8, ptr %ig.data19, i64 %loadN
%ig.val21 = load i8, ptr %ig.ptr20, align 1
%cmp.ext22 = zext i8 %ig.val21 to i64
%icmpN = icmp eq i64 %cmp.ext22, 125
br i1 %icmpN, label %if.then.56, label %if.else.57
if.merge.35: ; preds = %if.merge.58, %if.merge.38
br label %while.hdr.30
if.then.36: ; preds = %if.then.33
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
%ig.data27 = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr28 = getelementptr i8, ptr %ig.data27, i64 %addN
%ig.val29 = load i8, ptr %ig.ptr28, align 1
%cmp.ext30 = zext i8 %ig.val29 to i64
%icmpN = icmp eq i64 %cmp.ext30, 125
br i1 %icmpN, label %if.then.39, label %if.else.40
if.else.37: ; preds = %if.then.33
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.38
if.merge.38: ; preds = %if.merge.41, %if.else.37
br label %if.merge.35
if.then.39: ; preds = %if.then.36
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, %loadN
br i1 %icmpN, label %if.then.42, label %if.merge.43
if.else.40: ; preds = %if.then.36
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
%ig.data40 = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr41 = getelementptr i8, ptr %ig.data40, i64 %addN
%ig.val42 = load i8, ptr %ig.ptr41, align 1
%cmp.ext43 = zext i8 %ig.val42 to i64
%icmpN = icmp eq i64 %cmp.ext43, 123
br i1 %icmpN, label %if.then.53, label %if.else.54
if.merge.41: ; preds = %if.merge.55, %if.merge.43
br label %if.merge.38
if.then.42: ; preds = %if.then.39
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.88, i64 36 })
store { ptr, i64 } %call, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.89, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%sub = sub i64 %loadN, %loadN
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %sub)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.90, i64 4 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.43
if.merge.43: ; preds = %if.then.42, %if.then.39
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.91, i64 43 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.92, i64 5 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 2
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
store i64 %loadN, ptr %allocaN, align 8
br label %if.merge.41
if.then.53: ; preds = %if.else.40
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.93, i64 36 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.94, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, %loadN
%addN = add i64 %subN, 1
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %addN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.95, i64 4 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 2
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
store i64 %loadN, ptr %allocaN, align 8
br label %if.merge.55
if.else.54: ; preds = %if.else.40
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.55
if.merge.55: ; preds = %if.else.54, %if.then.53
br label %if.merge.41
if.then.56: ; preds = %if.else.34
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
%icmpN = icmp slt i64 %addN, %lenN
br i1 %icmpN, label %if.then.59, label %if.else.60
if.else.57: ; preds = %if.else.34
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.58
if.merge.58: ; preds = %if.merge.61, %if.else.57
br label %if.merge.35
if.then.59: ; preds = %if.then.56
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
%ig.data104 = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr105 = getelementptr i8, ptr %ig.data104, i64 %addN
%ig.val106 = load i8, ptr %ig.ptr105, align 1
%cmp.ext107 = zext i8 %ig.val106 to i64
%icmpN = icmp eq i64 %cmp.ext107, 125
br i1 %icmpN, label %if.then.62, label %if.else.63
if.else.60: ; preds = %if.then.56
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.61
if.merge.61: ; preds = %if.merge.64, %if.else.60
br label %if.merge.58
if.then.62: ; preds = %if.then.59
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.96, i64 36 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %loadN, %loadN
%addN = add i64 %subN, 1
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %addN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.98, i64 4 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 2
store i64 %addN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
store i64 %loadN, ptr %allocaN, align 8
br label %if.merge.64
if.else.63: ; preds = %if.then.59
%loadN = load i64, ptr %allocaN, align 8
%addN = add i64 %loadN, 1
store i64 %addN, ptr %allocaN, align 8
br label %if.merge.64
if.merge.64: ; preds = %if.else.63, %if.then.62
br label %if.merge.61
if.then.65: ; preds = %while.exit.32
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.99, i64 36 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%lenN = extractvalue { ptr, i64 } %loadN, 1
%loadN = load i64, ptr %allocaN, align 8
%subN = sub i64 %lenN, %loadN
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %subN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.101, i64 4 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.66
if.merge.66: ; preds = %if.then.65, %while.exit.32
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
ret { ptr, i64 } %loadN
}
; Function Attrs: nounwind
define internal i32 @must(ptr %0, i32 %1) #0 {
entry:
%alloca = alloca i32, align 4
store i32 %1, ptr %alloca, align 4
%load = load i32, ptr %alloca, align 4
%cmp.ext = sext i32 %load to i64
%icmp = icmp slt i64 %cmp.ext, 0
br i1 %icmp, label %if.then.0, label %if.merge.1
if.then.0: ; preds = %entry
ret i32 1
if.merge.1: ; preds = %entry
%loadN = load i32, ptr %alloca, align 4
%cmp.ext2 = sext i32 %loadN to i64
%icmpN = icmp eq i64 %cmp.ext2, 0
br i1 %icmpN, label %if.then.2, label %if.merge.3
if.then.2: ; preds = %if.merge.1
ret i32 2
if.merge.3: ; preds = %if.merge.1
ret i32 0
}
; Function Attrs: nounwind
define internal i32 @classify(ptr %0, i32 %1) #0 {
entry:
%alloca = alloca i32, align 4
store i32 %1, ptr %alloca, align 4
%load = load i32, ptr %alloca, align 4
%call = call i32 @must(ptr %0, i32 %load)
%icmp = icmp ne i32 %call, 0
br i1 %icmp, label %catch.handle.10, label %catch.merge.11
catch.handle.10: ; preds = %entry
%icmpN = icmp eq i32 %call, 1
br i1 %icmpN, label %if.then.12, label %if.merge.13
catch.merge.11: ; preds = %entry
ret i32 0
if.then.12: ; preds = %catch.handle.10
ret i32 1
if.merge.13: ; preds = %catch.handle.10
%icmpN = icmp eq i32 %call, 2
br i1 %icmpN, label %if.then.14, label %if.merge.15
if.then.14: ; preds = %if.merge.13
ret i32 2
if.merge.15: ; preds = %if.merge.13
ret i32 9
}
; Function Attrs: nounwind
define internal i32 @mclassify(ptr %0, i32 %1) #0 {
entry:
%alloca = alloca i32, align 4
store i32 %1, ptr %alloca, align 4
%load = load i32, ptr %alloca, align 4
%call = call i32 @must(ptr %0, i32 %load)
%icmp = icmp ne i32 %call, 0
br i1 %icmp, label %catch.handle.24, label %catch.merge.25
catch.handle.24: ; preds = %entry
switch i32 %call, label %match.arm.29 [
i32 1, label %match.arm.27
i32 2, label %match.arm.28
]
catch.merge.25: ; preds = %match.merge.26, %entry
ret i32 0
match.merge.26: ; No predecessors!
br label %catch.merge.25
match.arm.27: ; preds = %catch.handle.24
ret i32 11
match.arm.28: ; preds = %catch.handle.24
ret i32 22
match.arm.29: ; preds = %catch.handle.24
ret i32 99
}
; Function Attrs: nounwind
define internal i32 @handle_some(ptr %0, i32 %1) #0 {
entry:
%alloca = alloca i32, align 4
store i32 %1, ptr %alloca, align 4
%load = load i32, ptr %alloca, align 4
%call = call i32 @must(ptr %0, i32 %load)
%icmp = icmp ne i32 %call, 0
br i1 %icmp, label %catch.handle.16, label %catch.merge.17
catch.handle.16: ; preds = %entry
%icmpN = icmp eq i32 %call, 1
br i1 %icmpN, label %if.then.18, label %if.merge.19
catch.merge.17: ; preds = %entry
ret i32 0
if.then.18: ; preds = %catch.handle.16
ret i32 0
if.merge.19: ; preds = %catch.handle.16
ret i32 %call
}
; Function Attrs: nounwind
define i32 @main() #0 {
entry:
%alloca = alloca i32, align 4
%allocaN = alloca i32, align 4
%allocaN = alloca i32, align 4
store i32 0, ptr %alloca, align 4
%call = call i32 @must(ptr @__sx_default_context, i32 -1)
%icmp = icmp ne i32 %call, 0
br i1 %icmp, label %catch.handle.4, label %catch.merge.5
catch.handle.4: ; preds = %entry
%icmpN = icmp eq i32 %call, 1
br i1 %icmpN, label %if.then.6, label %if.merge.7
catch.merge.5: ; preds = %if.merge.7, %entry
%callN = call i32 @must(ptr @__sx_default_context, i32 5)
%icmpN = icmp ne i32 %callN, 0
br i1 %icmpN, label %catch.handle.8, label %catch.merge.9
if.then.6: ; preds = %catch.handle.4
%load = load i32, ptr %alloca, align 4
%add = add i32 %load, 1
store i32 %add, ptr %alloca, align 4
br label %if.merge.7
if.merge.7: ; preds = %if.then.6, %catch.handle.4
br label %catch.merge.5
catch.handle.8: ; preds = %catch.merge.5
%loadN = load i32, ptr %alloca, align 4
%addN = add i32 %loadN, 100
store i32 %addN, ptr %alloca, align 4
br label %catch.merge.9
catch.merge.9: ; preds = %catch.handle.8, %catch.merge.5
%loadN = load i32, ptr %alloca, align 4
%callN = call i32 @classify(ptr @__sx_default_context, i32 0)
%addN = add i32 %loadN, %callN
store i32 %addN, ptr %alloca, align 4
%loadN = load i32, ptr %alloca, align 4
%callN = call i32 @classify(ptr @__sx_default_context, i32 8)
%addN = add i32 %loadN, %callN
store i32 %addN, ptr %alloca, align 4
%callN = call i32 @handle_some(ptr @__sx_default_context, i32 0)
store i32 %callN, ptr %allocaN, align 4
%loadN = load i32, ptr %allocaN, align 4
%icmpN = icmp eq i32 %loadN, 2
br i1 %icmpN, label %if.then.20, label %if.merge.21
if.then.20: ; preds = %catch.merge.9
%loadN = load i32, ptr %alloca, align 4
%addN = add i32 %loadN, 4
store i32 %addN, ptr %alloca, align 4
br label %if.merge.21
if.merge.21: ; preds = %if.then.20, %catch.merge.9
%callN = call i32 @handle_some(ptr @__sx_default_context, i32 -1)
store i32 %callN, ptr %allocaN, align 4
%loadN = load i32, ptr %allocaN, align 4
%icmpN = icmp eq i32 %loadN, 1
br i1 %icmpN, label %if.then.22, label %if.merge.23
if.then.22: ; preds = %if.merge.21
%loadN = load i32, ptr %alloca, align 4
%addN = add i32 %loadN, 50
store i32 %addN, ptr %alloca, align 4
br label %if.merge.23
if.merge.23: ; preds = %if.then.22, %if.merge.21
%loadN = load i32, ptr %alloca, align 4
%callN = call i32 @mclassify(ptr @__sx_default_context, i32 -1)
%addN = add i32 %loadN, %callN
store i32 %addN, ptr %alloca, align 4
%loadN = load i32, ptr %alloca, align 4
call void @print__ct_sbcb4570e4e0d606e__pack_s32(ptr @__sx_default_context, i32 %loadN)
%loadN = load i32, ptr %alloca, align 4
ret i32 %loadN
}
; Function Attrs: nounwind
define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 {
entry:
%call = call ptr @CAllocator.alloc(ptr %0, ptr %1, i64 %2)
ret ptr %call
}
; Function Attrs: nounwind
define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 {
entry:
call void @CAllocator.dealloc(ptr %0, ptr %1, ptr %2)
ret void
}
; Function Attrs: nounwind
define internal void @print__ct_sbcb4570e4e0d606e__pack_s32(ptr %0, i32 %1) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.109, i64 17 }, ptr %alloca, align 8
%allocaN = alloca i32, align 4
store i32 %1, ptr %allocaN, align 4
%allocaN = alloca [1 x { i64, i64 }], align 8
%load = load i32, ptr %allocaN, align 4
%sN = sext i32 %load to i64
%ba.val = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
%igp.ptr = getelementptr { i64, i64 }, ptr %allocaN, i64 0
store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
%allocaN = alloca { ptr, i64 }, align 8
%igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
store ptr %igp.ptr4, ptr %gep, align 8
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
store i64 1, ptr %gepN, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.110, i64 0 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%call = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 0, i64 14)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %call)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i32, ptr %allocaN, align 4
%sN = sext i32 %loadN to i64
%ba.val13 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val13)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 16, i64 1)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%str.ptr = extractvalue { ptr, i64 } %loadN, 0
%str.len = extractvalue { ptr, i64 } %loadN, 1
%2 = call i64 @write(i32 1, ptr %str.ptr, i64 %str.len)
ret void
}
; Function Attrs: nounwind
define internal { ptr, i64 } @__insert_0(ptr %0) #0 {
entry:
%call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.111, i64 17 })
ret { ptr, i64 } %call
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__Source_Location(ptr %0, { { ptr, i64 }, i32, i32, { ptr, i64 } } %1) #0 {
entry:
%alloca = alloca { { ptr, i64 }, i32, i32, { ptr, i64 } }, align 8
%ba.tmp = alloca { ptr, i64 }, align 8
%ba.tmp26 = alloca { ptr, i64 }, align 8
store { { ptr, i64 }, i32, i32, { ptr, i64 } } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.112, i64 15 }, { ptr, i64 } { ptr @str.113, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.135
while.hdr.135: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 4
br i1 %icmp, label %while.body.136, label %while.exit.137
while.body.136: ; preds = %while.hdr.135
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.138, label %if.merge.139
while.exit.137: ; preds = %while.hdr.135
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.114, i64 1 })
ret { ptr, i64 } %callN
if.then.138: ; preds = %while.body.136
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.115, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.139
if.merge.139: ; preds = %if.then.138, %while.body.136
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.119, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { { ptr, i64 }, i32, i32, { ptr, i64 } }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
i64 2, label %fv.case20
i64 3, label %fv.case24
]
fv.merge: ; preds = %fv.default, %fv.case24, %fv.case20, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val23, %fv.case20 ], [ %fv.val28, %fv.case24 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.135
fv.default: ; preds = %if.merge.139
br label %fv.merge
fv.case: ; preds = %if.merge.139
%fv.field = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 0
store { ptr, i64 } %fv.field, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%fv.val = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.139
%fv.field18 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 1
%sN = sext i32 %fv.field18 to i64
%fv.val19 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
br label %fv.merge
fv.case20: ; preds = %if.merge.139
%fv.field21 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 2
%sN = sext i32 %fv.field21 to i64
%fv.val23 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
br label %fv.merge
fv.case24: ; preds = %if.merge.139
%fv.field25 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 3
store { ptr, i64 } %fv.field25, ptr %ba.tmp26, align 8
%ba.p2i27 = ptrtoint ptr %ba.tmp26 to i64
%fv.val28 = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i27, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %1) #0 {
entry:
%alloca = alloca { ptr, ptr, ptr }, align 8
store { ptr, ptr, ptr } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.120, i64 9 }, { ptr, i64 } { ptr @str.121, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.140
while.hdr.140: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 3
br i1 %icmp, label %while.body.141, label %while.exit.142
while.body.141: ; preds = %while.hdr.140
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.143, label %if.merge.144
while.exit.142: ; preds = %while.hdr.140
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.122, i64 1 })
ret { ptr, i64 } %callN
if.then.143: ; preds = %while.body.141
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.123, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.144
if.merge.144: ; preds = %if.then.143, %while.body.141
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.127, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.128, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, ptr, ptr }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
i64 2, label %fv.case21
]
fv.merge: ; preds = %fv.default, %fv.case21, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val20, %fv.case17 ], [ %fv.val24, %fv.case21 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.140
fv.default: ; preds = %if.merge.144
br label %fv.merge
fv.case: ; preds = %if.merge.144
%fv.field = extractvalue { ptr, ptr, ptr } %loadN, 0
%pNi = ptrtoint ptr %fv.field to i64
%fv.val = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.144
%fv.field18 = extractvalue { ptr, ptr, ptr } %loadN, 1
%pNi19 = ptrtoint ptr %fv.field18 to i64
%fv.val20 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi19, 1
br label %fv.merge
fv.case21: ; preds = %if.merge.144
%fv.field22 = extractvalue { ptr, ptr, ptr } %loadN, 2
%pNi23 = ptrtoint ptr %fv.field22 to i64
%fv.val24 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi23, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %1) #0 {
entry:
%alloca = alloca {}, align 8
store {} %1, ptr %alloca, align 1
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.129, i64 10 }, { ptr, i64 } { ptr @str.130, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.145
while.hdr.145: ; preds = %if.merge.149, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 0
br i1 %icmp, label %while.body.146, label %while.exit.147
while.body.146: ; preds = %while.hdr.145
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.148, label %if.merge.149
while.exit.147: ; preds = %while.hdr.145
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.131, i64 1 })
ret { ptr, i64 } %callN
if.then.148: ; preds = %while.body.146
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.132, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.149
if.merge.149: ; preds = %if.then.148, %while.body.146
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.133, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.134, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load {}, ptr %alloca, align 1
%loadN = load i64, ptr %allocaN, align 8
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } { i64 17, i64 0 })
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.145
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %1) #0 {
entry:
%alloca = alloca { i64 }, align 8
store { i64 } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.135, i64 3 }, { ptr, i64 } { ptr @str.136, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.150
while.hdr.150: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 1
br i1 %icmp, label %while.body.151, label %while.exit.152
while.body.151: ; preds = %while.hdr.150
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.153, label %if.merge.154
while.exit.152: ; preds = %while.hdr.150
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.137, i64 1 })
ret { ptr, i64 } %callN
if.then.153: ; preds = %while.body.151
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.138, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.154
if.merge.154: ; preds = %if.then.153, %while.body.151
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.140, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.141, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
]
fv.merge: ; preds = %fv.default, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.150
fv.default: ; preds = %if.merge.154
br label %fv.merge
fv.case: ; preds = %if.merge.154
%fv.field = extractvalue { i64 } %loadN, 0
%fv.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %1) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.142, i64 10 }, { ptr, i64 } { ptr @str.143, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.155
while.hdr.155: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 2
br i1 %icmp, label %while.body.156, label %while.exit.157
while.body.156: ; preds = %while.hdr.155
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.158, label %if.merge.159
while.exit.157: ; preds = %while.hdr.155
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.144, i64 1 })
ret { ptr, i64 } %callN
if.then.158: ; preds = %while.body.156
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.145, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.159
if.merge.159: ; preds = %if.then.158, %while.body.156
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.148, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.149, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
]
fv.merge: ; preds = %fv.default, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.155
fv.default: ; preds = %if.merge.159
br label %fv.merge
fv.case: ; preds = %if.merge.159
%fv.field = extractvalue { ptr, i64 } %loadN, 0
%pNi = ptrtoint ptr %fv.field to i64
%fv.val = insertvalue { i64, i64 } { i64 26, i64 undef }, i64 %pNi, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.159
%fv.field18 = extractvalue { ptr, i64 } %loadN, 1
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %1) #0 {
entry:
%alloca = alloca { ptr, i64, { ptr, ptr, ptr } }, align 8
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
store { ptr, i64, { ptr, ptr, ptr } } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.150, i64 5 }, { ptr, i64 } { ptr @str.151, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.160
while.hdr.160: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 3
br i1 %icmp, label %while.body.161, label %while.exit.162
while.body.161: ; preds = %while.hdr.160
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.163, label %if.merge.164
while.exit.162: ; preds = %while.hdr.160
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.152, i64 1 })
ret { ptr, i64 } %callN
if.then.163: ; preds = %while.body.161
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.153, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.164
if.merge.164: ; preds = %if.then.163, %while.body.161
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.157, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.158, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64, { ptr, ptr, ptr } }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
i64 2, label %fv.case20
]
fv.merge: ; preds = %fv.default, %fv.case20, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.160
fv.default: ; preds = %if.merge.164
br label %fv.merge
fv.case: ; preds = %if.merge.164
%fv.field = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 0
%pNi = ptrtoint ptr %fv.field to i64
%fv.val = insertvalue { i64, i64 } { i64 26, i64 undef }, i64 %pNi, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.164
%fv.field18 = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 1
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
br label %fv.merge
fv.case20: ; preds = %if.merge.164
%fv.field21 = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 2
store { ptr, ptr, ptr } %fv.field21, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%fv.val22 = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %1) #0 {
entry:
%alloca = alloca { ptr, i64, i64 }, align 8
store { ptr, i64, i64 } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.159, i64 8 }, { ptr, i64 } { ptr @str.160, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.165
while.hdr.165: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 3
br i1 %icmp, label %while.body.166, label %while.exit.167
while.body.166: ; preds = %while.hdr.165
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.168, label %if.merge.169
while.exit.167: ; preds = %while.hdr.165
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.161, i64 1 })
ret { ptr, i64 } %callN
if.then.168: ; preds = %while.body.166
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.162, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.169
if.merge.169: ; preds = %if.then.168, %while.body.166
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.166, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.167, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
i64 2, label %fv.case20
]
fv.merge: ; preds = %fv.default, %fv.case20, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.165
fv.default: ; preds = %if.merge.169
br label %fv.merge
fv.case: ; preds = %if.merge.169
%fv.field = extractvalue { ptr, i64, i64 } %loadN, 0
%pNi = ptrtoint ptr %fv.field to i64
%fv.val = insertvalue { i64, i64 } { i64 29, i64 undef }, i64 %pNi, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.169
%fv.field18 = extractvalue { ptr, i64, i64 } %loadN, 1
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
br label %fv.merge
fv.case20: ; preds = %if.merge.169
%fv.field21 = extractvalue { ptr, i64, i64 } %loadN, 2
%fv.val22 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field21, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %1) #0 {
entry:
%alloca = alloca { { ptr, ptr, ptr }, i64, i64, i64 }, align 8
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
store { { ptr, ptr, ptr }, i64, i64, i64 } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.168, i64 17 }, { ptr, i64 } { ptr @str.169, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.170
while.hdr.170: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 4
br i1 %icmp, label %while.body.171, label %while.exit.172
while.body.171: ; preds = %while.hdr.170
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.173, label %if.merge.174
while.exit.172: ; preds = %while.hdr.170
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.170, i64 1 })
ret { ptr, i64 } %callN
if.then.173: ; preds = %while.body.171
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.171, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.174
if.merge.174: ; preds = %if.then.173, %while.body.171
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names.176, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.177, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
i64 2, label %fv.case20
i64 3, label %fv.case23
]
fv.merge: ; preds = %fv.default, %fv.case23, %fv.case20, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ %fv.val25, %fv.case23 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.170
fv.default: ; preds = %if.merge.174
br label %fv.merge
fv.case: ; preds = %if.merge.174
%fv.field = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 0
store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%fv.val = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.174
%fv.field18 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 1
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
br label %fv.merge
fv.case20: ; preds = %if.merge.174
%fv.field21 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 2
%fv.val22 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field21, 1
br label %fv.merge
fv.case23: ; preds = %if.merge.174
%fv.field24 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 3
%fv.val25 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field24, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %1) #0 {
entry:
%alloca = alloca { { ptr, ptr, ptr }, ptr }, align 8
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
store { { ptr, ptr, ptr }, ptr } %1, ptr %alloca, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.178, i64 7 }, { ptr, i64 } { ptr @str.179, i64 1 })
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } %call, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.175
while.hdr.175: ; preds = %fv.merge, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 2
br i1 %icmp, label %while.body.176, label %while.exit.177
while.body.176: ; preds = %while.hdr.175
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.178, label %if.merge.179
while.exit.177: ; preds = %while.hdr.175
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.180, i64 1 })
ret { ptr, i64 } %callN
if.then.178: ; preds = %while.body.176
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.181, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.179
if.merge.179: ; preds = %if.then.178, %while.body.176
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.184, i64 0, i64 %loadN
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.185, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { { ptr, ptr, ptr }, ptr }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
switch i64 %loadN, label %fv.default [
i64 0, label %fv.case
i64 1, label %fv.case17
]
fv.merge: ; preds = %fv.default, %fv.case17, %fv.case
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ undef, %fv.default ]
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.175
fv.default: ; preds = %if.merge.179
br label %fv.merge
fv.case: ; preds = %if.merge.179
%fv.field = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 0
store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%fv.val = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
br label %fv.merge
fv.case17: ; preds = %if.merge.179
%fv.field18 = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 1
%pNi = ptrtoint ptr %fv.field18 to i64
%fv.val19 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
br label %fv.merge
}
; Function Attrs: nounwind
define internal { ptr, i64 } @array_to_string__AR_4_s64(ptr %0, [4 x i64] %1) #0 {
entry:
%alloca = alloca [4 x i64], align 8
%ig.tmp = alloca [4 x i64], align 8
store [4 x i64] %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.186, i64 1 }, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.184
while.hdr.184: ; preds = %if.merge.188, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 4
br i1 %icmp, label %while.body.185, label %while.exit.186
while.body.185: ; preds = %while.hdr.184
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.187, label %if.merge.188
while.exit.186: ; preds = %while.hdr.184
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.187, i64 1 })
ret { ptr, i64 } %call
if.then.187: ; preds = %while.body.185
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.188, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.188
if.merge.188: ; preds = %if.then.187, %while.body.185
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [4 x i64], ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
store [4 x i64] %loadN, ptr %ig.tmp, align 8
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 %loadN
%ig.val = load i64, ptr %ig.ptr, align 8
%ba.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %ig.val, 1
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.184
}
; Function Attrs: nounwind
define internal { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %1) #0 {
entry:
%alloca = alloca [1 x { i64, i64 }], align 8
%ig.tmp = alloca [1 x { i64, i64 }], align 8
%ba.tmp = alloca { i64, i64 }, align 8
store [1 x { i64, i64 }] %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.189, i64 1 }, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.189
while.hdr.189: ; preds = %if.merge.193, %entry
%load = load i64, ptr %allocaN, align 8
%icmp = icmp slt i64 %load, 1
br i1 %icmp, label %while.body.190, label %while.exit.191
while.body.190: ; preds = %while.hdr.189
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.192, label %if.merge.193
while.exit.191: ; preds = %while.hdr.189
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.190, i64 1 })
ret { ptr, i64 } %call
if.then.192: ; preds = %while.body.190
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.191, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.193
if.merge.193: ; preds = %if.then.192, %while.body.190
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load [1 x { i64, i64 }], ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
store [1 x { i64, i64 }] %loadN, ptr %ig.tmp, align 8
%ig.ptr = getelementptr [1 x { i64, i64 }], ptr %ig.tmp, i64 0, i64 %loadN
%ig.val = load { i64, i64 }, ptr %ig.ptr, align 8
store { i64, i64 } %ig.val, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %ba.p2i, 1
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.189
}
; Function Attrs: nounwind
define internal { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %1) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
%ba.tmp = alloca { ptr, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.192, i64 1 }, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.198
while.hdr.198: ; preds = %if.merge.202, %entry
%load = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%len = extractvalue { ptr, i64 } %loadN, 1
%icmp = icmp slt i64 %load, %len
br i1 %icmp, label %while.body.199, label %while.exit.200
while.body.199: ; preds = %while.hdr.198
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.201, label %if.merge.202
while.exit.200: ; preds = %while.hdr.198
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.193, i64 1 })
ret { ptr, i64 } %call
if.then.201: ; preds = %while.body.199
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.194, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.202
if.merge.202: ; preds = %if.then.201, %while.body.199
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%ig.data = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr = getelementptr { ptr, i64 }, ptr %ig.data, i64 %loadN
%ig.val = load { ptr, i64 }, ptr %ig.ptr, align 8
store { ptr, i64 } %ig.val, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%ba.val = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i, 1
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.198
}
; Function Attrs: nounwind
define internal { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %1) #0 {
entry:
%alloca = alloca { ptr, i64 }, align 8
%ba.tmp = alloca { i64, i64 }, align 8
store { ptr, i64 } %1, ptr %alloca, align 8
%allocaN = alloca { ptr, i64 }, align 8
store { ptr, i64 } { ptr @str.195, i64 1 }, ptr %allocaN, align 8
%allocaN = alloca i64, align 8
store i64 0, ptr %allocaN, align 8
br label %while.hdr.203
while.hdr.203: ; preds = %if.merge.207, %entry
%load = load i64, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%len = extractvalue { ptr, i64 } %loadN, 1
%icmp = icmp slt i64 %load, %len
br i1 %icmp, label %while.body.204, label %while.exit.205
while.body.204: ; preds = %while.hdr.203
%loadN = load i64, ptr %allocaN, align 8
%icmpN = icmp sgt i64 %loadN, 0
br i1 %icmpN, label %if.then.206, label %if.merge.207
while.exit.205: ; preds = %while.hdr.203
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.196, i64 1 })
ret { ptr, i64 } %call
if.then.206: ; preds = %while.body.204
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.197, i64 2 })
store { ptr, i64 } %callN, ptr %allocaN, align 8
br label %if.merge.207
if.merge.207: ; preds = %if.then.206, %while.body.204
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
%loadN = load { ptr, i64 }, ptr %alloca, align 8
%loadN = load i64, ptr %allocaN, align 8
%ig.data = extractvalue { ptr, i64 } %loadN, 0
%ig.ptr = getelementptr { i64, i64 }, ptr %ig.data, i64 %loadN
%ig.val = load { i64, i64 }, ptr %ig.ptr, align 8
store { i64, i64 } %ig.val, ptr %ba.tmp, align 8
%ba.p2i = ptrtoint ptr %ba.tmp to i64
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %ba.p2i, 1
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
store { ptr, i64 } %callN, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%add = add i64 %loadN, 1
store i64 %add, ptr %allocaN, align 8
br label %while.hdr.203
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_void(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.229, label %if.else.230
if.then.229: ; preds = %entry
br label %if.merge.231
if.else.230: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.200, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.199, i64 5 }, { ptr, i64 } %callN)
br label %if.merge.231
if.merge.231: ; preds = %if.else.230, %if.then.229
%bp = phi { ptr, i64 } [ { ptr @str.198, i64 4 }, %if.then.229 ], [ %callN, %if.else.230 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.245, label %if.else.246
if.then.245: ; preds = %entry
br label %if.merge.247
if.else.246: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.203, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.202, i64 11 }, { ptr, i64 } %callN)
br label %if.merge.247
if.merge.247: ; preds = %if.else.246, %if.then.245
%bp = phi { ptr, i64 } [ { ptr @str.201, i64 4 }, %if.then.245 ], [ %callN, %if.else.246 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.248, label %if.else.249
if.then.248: ; preds = %entry
br label %if.merge.250
if.else.249: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.206, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.205, i64 4 }, { ptr, i64 } %callN)
br label %if.merge.250
if.merge.250: ; preds = %if.else.249, %if.then.248
%bp = phi { ptr, i64 } [ { ptr @str.204, i64 4 }, %if.then.248 ], [ %callN, %if.else.249 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.251, label %if.else.252
if.then.251: ; preds = %entry
br label %if.merge.253
if.else.252: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.209, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.208, i64 11 }, { ptr, i64 } %callN)
br label %if.merge.253
if.merge.253: ; preds = %if.else.252, %if.then.251
%bp = phi { ptr, i64 } [ { ptr @str.207, i64 4 }, %if.then.251 ], [ %callN, %if.else.252 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.254, label %if.else.255
if.then.254: ; preds = %entry
br label %if.merge.256
if.else.255: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.212, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.211, i64 6 }, { ptr, i64 } %callN)
br label %if.merge.256
if.merge.256: ; preds = %if.else.255, %if.then.254
%bp = phi { ptr, i64 } [ { ptr @str.210, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
store ptr %load, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.257, label %if.else.258
if.then.257: ; preds = %entry
br label %if.merge.259
if.else.258: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.215, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.214, i64 5 }, { ptr, i64 } %callN)
br label %if.merge.259
if.merge.259: ; preds = %if.else.258, %if.then.257
%bp = phi { ptr, i64 } [ { ptr @str.213, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.260, label %if.else.261
if.then.260: ; preds = %entry
br label %if.merge.262
if.else.261: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.218, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.217, i64 9 }, { ptr, i64 } %callN)
br label %if.merge.262
if.merge.262: ; preds = %if.else.261, %if.then.260
%bp = phi { ptr, i64 } [ { ptr @str.216, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.263, label %if.else.264
if.then.263: ; preds = %entry
br label %if.merge.265
if.else.264: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.221, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.220, i64 18 }, { ptr, i64 } %callN)
br label %if.merge.265
if.merge.265: ; preds = %if.else.264, %if.then.263
%bp = phi { ptr, i64 } [ { ptr @str.219, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.266, label %if.else.267
if.then.266: ; preds = %entry
br label %if.merge.268
if.else.267: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.224, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.223, i64 12 }, { ptr, i64 } %callN)
br label %if.merge.268
if.merge.268: ; preds = %if.else.267, %if.then.266
%bp = phi { ptr, i64 } [ { ptr @str.222, i64 4 }, %if.then.266 ], [ %callN, %if.else.267 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.269, label %if.else.270
if.then.269: ; preds = %entry
br label %if.merge.271
if.else.270: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.227, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.226, i64 4 }, { ptr, i64 } %callN)
br label %if.merge.271
if.merge.271: ; preds = %if.else.270, %if.then.269
%bp = phi { ptr, i64 } [ { ptr @str.225, i64 4 }, %if.then.269 ], [ %callN, %if.else.270 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.272, label %if.else.273
if.then.272: ; preds = %entry
br label %if.merge.274
if.else.273: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.230, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.229, i64 6 }, { ptr, i64 } %callN)
br label %if.merge.274
if.merge.274: ; preds = %if.else.273, %if.then.272
%bp = phi { ptr, i64 } [ { ptr @str.228, i64 4 }, %if.then.272 ], [ %callN, %if.else.273 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_s32(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.275, label %if.else.276
if.then.275: ; preds = %entry
br label %if.merge.277
if.else.276: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.233, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.232, i64 4 }, { ptr, i64 } %callN)
br label %if.merge.277
if.merge.277: ; preds = %if.else.276, %if.then.275
%bp = phi { ptr, i64 } [ { ptr @str.231, i64 4 }, %if.then.275 ], [ %callN, %if.else.276 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_error_set(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.278, label %if.else.279
if.then.278: ; preds = %entry
br label %if.merge.280
if.else.279: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.236, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.235, i64 10 }, { ptr, i64 } %callN)
br label %if.merge.280
if.merge.280: ; preds = %if.else.279, %if.then.278
%bp = phi { ptr, i64 } [ { ptr @str.234, i64 4 }, %if.then.278 ], [ %callN, %if.else.279 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.281, label %if.else.282
if.then.281: ; preds = %entry
br label %if.merge.283
if.else.282: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.239, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.238, i64 7 }, { ptr, i64 } %callN)
br label %if.merge.283
if.merge.283: ; preds = %if.else.282, %if.then.281
%bp = phi { ptr, i64 } [ { ptr @str.237, i64 4 }, %if.then.281 ], [ %callN, %if.else.282 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.284, label %if.else.285
if.then.284: ; preds = %entry
br label %if.merge.286
if.else.285: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.242, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.241, i64 4 }, { ptr, i64 } %callN)
br label %if.merge.286
if.merge.286: ; preds = %if.else.285, %if.then.284
%bp = phi { ptr, i64 } [ { ptr @str.240, i64 4 }, %if.then.284 ], [ %callN, %if.else.285 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.287, label %if.else.288
if.then.287: ; preds = %entry
br label %if.merge.289
if.else.288: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.245, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.244, i64 7 }, { ptr, i64 } %callN)
br label %if.merge.289
if.merge.289: ; preds = %if.else.288, %if.then.287
%bp = phi { ptr, i64 } [ { ptr @str.243, i64 4 }, %if.then.287 ], [ %callN, %if.else.288 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.290, label %if.else.291
if.then.290: ; preds = %entry
br label %if.merge.292
if.else.291: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.248, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.247, i64 6 }, { ptr, i64 } %callN)
br label %if.merge.292
if.merge.292: ; preds = %if.else.291, %if.then.290
%bp = phi { ptr, i64 } [ { ptr @str.246, i64 4 }, %if.then.290 ], [ %callN, %if.else.291 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.293, label %if.else.294
if.then.293: ; preds = %entry
br label %if.merge.295
if.else.294: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.251, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.250, i64 3 }, { ptr, i64 } %callN)
br label %if.merge.295
if.merge.295: ; preds = %if.else.294, %if.then.293
%bp = phi { ptr, i64 } [ { ptr @str.249, i64 4 }, %if.then.293 ], [ %callN, %if.else.294 ]
ret { ptr, i64 } %bp
}
; Function Attrs: nounwind
define internal { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %1) #0 {
entry:
%alloca = alloca ptr, align 8
store ptr %1, ptr %alloca, align 8
%allocaN = alloca i64, align 8
%load = load ptr, ptr %alloca, align 8
%pti = ptrtoint ptr %load to i64
store i64 %pti, ptr %allocaN, align 8
%loadN = load i64, ptr %allocaN, align 8
%icmp = icmp eq i64 %loadN, 0
br i1 %icmp, label %if.then.296, label %if.else.297
if.then.296: ; preds = %entry
br label %if.merge.298
if.else.297: ; preds = %entry
%loadN = load i64, ptr %allocaN, align 8
%call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.254, i64 3 }, { ptr, i64 } %call)
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.253, i64 5 }, { ptr, i64 } %callN)
br label %if.merge.298
if.merge.298: ; preds = %if.else.297, %if.then.296
%bp = phi { ptr, i64 } [ { ptr @str.252, i64 4 }, %if.then.296 ], [ %callN, %if.else.297 ]
ret { ptr, i64 } %bp
}
declare i64 @write(i32, ptr, i64)
Reference in New Issue View Git Blame Copy Permalink