Confronta il testo

Trova la differenza tra due file di testo

Editor live

Comprimi invariate

Senza a capo

Layout

Livello di dettaglio

Evidenziazione sintassi

Diffchecker Desktop Il modo più sicuro per usare Diffchecker. Ottieni l'app Diffchecker Desktop: i tuoi diff non lasciano mai il tuo computer!Ottieni Desktop

Zig output

Creato 2 anni faIl diff non scade mai

3 rimozioni

Linee
Totale
Rimosso

Caratteri
Totale
Rimosso

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

281 linee

3 aggiunte

Linee
Totale
Aggiunto

Caratteri
Totale
Aggiunto

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

281 linee

; ModuleID = 'biggy'

source_filename = "biggy"

target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"

target triple = "x86_64-unknown-macosx14.5.0-unknown"

%Target.Cpu.Feature.Set = type { [5 x i64] }

%Target.Cpu.Model = type { { ptr, i64 }, { ptr, i64 }, %Target.Cpu.Feature.Set }

%Target.Cpu = type { ptr, %Target.Cpu.Feature.Set, i6, [7 x i8] }

%SemanticVersion = type { i64, i64, i64, { ptr, i64 }, { ptr, i64 } }

%SemanticVersion.Range = type { %SemanticVersion, %SemanticVersion }

%Target.Os.LinuxVersionRange = type { %SemanticVersion.Range, %SemanticVersion }

%Target.Os.VersionRange = type { %Target.Os.LinuxVersionRange }

%Target.Os = type { %Target.Os.VersionRange, i6, [7 x i8] }

%c.darwin.Sigaction.Sigaction__union_2578 = type { ptr }

%c.darwin.Sigaction = type { %c.darwin.Sigaction.Sigaction__union_2578, i32, i32 }

%fs.File = type { i32 }

%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))" = type { %fs.File }

%io.Writer = type { ptr, ptr }

%std.Options = type { i64, i1, i2, i1, i1, i1, i1, i2, [1 x i8] }

%Target.DynamicLinker = type { [255 x i8], i8 }

%Target = type { %Target.Cpu, %Target.Os, i6, i4, %Target.DynamicLinker, [6 x i8] }

%macho.mach_header_64 = type { i32, i32, i32, i32, i32, i32, i32, i32 }

%c.darwin.os_unfair_lock = type { i32 }

%Thread.Mutex.DarwinImpl = type { %c.darwin.os_unfair_lock }

%Thread.Mutex = type { %Thread.Mutex.DarwinImpl }

%Thread.Mutex.Recursive = type { i64, i64, %Thread.Mutex, [4 x i8] }

%fmt.FormatOptions = type { { i64, i8, [7 x i8] }, { i64, i8, [7 x i8] }, i21, i2, [3 x i8] }

%"io.fixed_buffer_stream.FixedBufferStream([]u8)" = type { { ptr, i64 }, i64 }

%"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))" = type { ptr }

%Thread.PosixThreadImpl = type { ptr }

%Thread = type { %Thread.PosixThreadImpl }

%"atomic.Value(u32)" = type { i32 }

%Thread.ResetEvent.FutexImpl = type { %"atomic.Value(u32)" }

%Thread.ResetEvent = type { %Thread.ResetEvent.FutexImpl }

%Progress = type { { %Thread, i8, [7 x i8] }, i64, i64, { ptr, i64 }, { ptr, i64 }, { ptr, i64 }, { ptr, i64 }, %fs.File, %Thread.ResetEvent, i32, i16, i16, i2, i1, i1, i8, [4 x i8] }

%"atomic.Value(u8)" = type { i8 }

%builtin.StackTrace = type { i64, { ptr, i64 } }

%Progress.Node.Storage = type { i32, i32, [40 x i8] }

@builtin.zig_backend = internal unnamed_addr constant i64 2, align 8

@Target.Cpu.Feature.Set.empty = internal unnamed_addr constant %Target.Cpu.Feature.Set zeroinitializer, align 8

@Target.x86.cpu.skylake = internal unnamed_addr constant %Target.Cpu.Model { { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, %Target.Cpu.Feature.Set { [5 x i64] [i64 4703606015143248112, i64 2308508483300179218, i64 256986653737092120, i64 0, i64 0] } }, align 8

@__anon_280 = internal unnamed_addr constant [8 x i8] c"skylake\00", align 1

@builtin.cpu = internal unnamed_addr constant %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, align 8

@start.simplified_logic = internal unnamed_addr constant i1 false, align 1

@builtin.output_mode = internal unnamed_addr constant i2 0, align 1

@builtin.link_libc = internal unnamed_addr constant i1 true, align 1

@start.native_arch = internal unnamed_addr constant i6 -27, align 1

@os.argv = internal unnamed_addr global { ptr, i64 } undef, align 8

@os.environ = internal unnamed_addr global { ptr, i64 } undef, align 8

@builtin.os = internal unnamed_addr constant { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, align 8

@__anon_1669 = internal unnamed_addr constant { { ptr }, i32, i32 } { { ptr } { ptr getelementptr inbounds (i8, ptr @start.noopSigHandler, i64 0) }, i32 0, i32 0 }, align 8

@__zig_err_name_table = private unnamed_addr constant ptr @68, align 8

@builtin.mode = internal unnamed_addr constant i2 -2, align 1

@debug.runtime_safety = internal unnamed_addr constant i1 false, align 1

@debug.default_enable_segfault_handler = internal unnamed_addr constant i1 false, align 1

@log.default_level = internal unnamed_addr constant i2 0, align 1

@std.options = internal unnamed_addr constant %std.Options { i64 3, i1 false, i2 0, i1 false, i1 true, i1 false, i1 false, i2 -2, [1 x i8] undef }, align 8

@debug.enable_segfault_handler = internal unnamed_addr constant i1 false, align 1

@posix.use_libc = internal unnamed_addr constant i1 true, align 1

@c.native_os = internal unnamed_addr constant i6 10, align 1

@c.darwin.empty_sigset = internal unnamed_addr constant i32 0, align 4

@posix.empty_sigset = internal unnamed_addr constant i32 0, align 4

@builtin.abi = internal unnamed_addr constant i6 0, align 1

@builtin.object_format = internal unnamed_addr constant i4 3, align 1

@Target.DynamicLinker.none = internal unnamed_addr constant %Target.DynamicLinker { [255 x i8] undef, i8 0 }, align 1

@builtin.target = internal unnamed_addr constant { %Target.Cpu, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] }, i6, i4, %Target.DynamicLinker, [6 x i8] } { %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, i6 0, i4 3, %Target.DynamicLinker { [255 x i8] [i8 47, i8 117, i8 115, i8 114, i8 47, i8 108, i8 105, i8 98, i8 47, i8 100, i8 121, i8 108, i8 100, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef], i8 13 }, [6 x i8] undef }, align 8

@_mh_execute_header = weak_odr dso_local global %macho.mach_header_64 undef, align 4

@__anon_2157 = internal unnamed_addr constant [16 x i8] c"(msg truncated)\00", align 1

@Progress.stderr_mutex = internal unnamed_addr global %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8

@0 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8

@__anon_1474 = internal unnamed_addr constant [5 x i8] c"{d}\0A\00", align 1

@__anon_1704 = internal unnamed_addr constant [40 x i8] c"failed to set noop SIGPIPE handler: {s}\00", align 1

@1 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8

@2 = private unnamed_addr constant { { ptr, i64 }, i16, [6 x i8] } { { ptr, i64 } undef, i16 5, [6 x i8] undef }, align 8

@Thread.native_os = internal unnamed_addr constant i6 10, align 1

@builtin.single_threaded = internal unnamed_addr constant i1 false, align 1

@Thread.Mutex.Recursive.invalid_thread_id = internal unnamed_addr constant i64 -1, align 8

@Thread.Mutex.Recursive.init = internal unnamed_addr constant %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8

@Progress.global_progress = internal unnamed_addr global %Progress { { %Thread, i8, [7 x i8] } { %Thread undef, i8 0, [7 x i8] undef }, i64 undef, i64 undef, { ptr, i64 } undef, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_parents_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_storage_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_freelist_buffer, i64 0), i64 83 }, %fs.File undef, %Thread.ResetEvent zeroinitializer, i32 0, i16 0, i16 0, i2 0, i1 false, i1 false, i8 -1, [4 x i8] undef }, align 8

@3 = private unnamed_addr constant [3 x i8] c"\1B[J", align 1

@io.is_windows = internal unnamed_addr constant i1 false, align 1

@fs.File.is_windows = internal unnamed_addr constant i1 false, align 1

@4 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8

@5 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 7, [6 x i8] undef }, align 8

@6 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 14, [6 x i8] undef }, align 8

@7 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 12, [6 x i8] undef }, align 8

@8 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 2, [6 x i8] undef }, align 8

@9 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 3, [6 x i8] undef }, align 8

@10 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 4, [6 x i8] undef }, align 8

@11 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8

@12 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 8, [6 x i8] undef }, align 8

@13 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 9, [6 x i8] undef }, align 8

@14 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 15, [6 x i8] undef }, align 8

@15 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 6, [6 x i8] undef }, align 8

@fmt.max_format_args = internal unnamed_addr constant i16 32, align 2

@__anon_3237 = internal unnamed_addr constant [8 x i8] c"{ ... }\00", align 1

@debug.panic_stage = internal thread_local unnamed_addr global i64 0, align 8

@debug.panicking = internal unnamed_addr global %"atomic.Value(u8)" zeroinitializer, align 1

@Progress.node_parents_buffer = internal unnamed_addr global [83 x i8] undef, align 1

@Progress.node_storage_buffer = internal unnamed_addr global [83 x %Progress.Node.Storage] undef, align 4

@Progress.node_freelist_buffer = internal unnamed_addr global [83 x i8] undef, align 1

@Progress.is_windows = internal unnamed_addr constant i1 false, align 1

@Thread.use_pthreads = internal unnamed_addr constant i1 true, align 1

@Progress.clear = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3049, i64 0), align 8

@__anon_3049 = internal unnamed_addr constant [4 x i8] c"\1B[J\00", align 1

@posix.native_os = internal unnamed_addr constant i6 10, align 1

@fmt.ANY = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3156, i64 0), align 8

@__anon_3156 = internal unnamed_addr constant [4 x i8] c"any\00", align 1

@16 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2

@17 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2

@18 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2

@19 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2

@20 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 23, i3 undef, [1 x i8] undef }, align 2

@21 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 24, [6 x i8] undef }, align 8

@__anon_3651 = internal unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1

@__anon_3683 = internal unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1

@22 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8

@23 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8

@posix.unexpected_error_tracing = internal unnamed_addr constant i1 false, align 1

@__anon_3758 = internal unnamed_addr constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 1

@__anon_3790 = internal unnamed_addr constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 1

@unicode.native_endian = internal unnamed_addr constant i1 true, align 1

@mem.native_endian = internal unnamed_addr constant i1 true, align 1

@24 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2

@25 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2

@26 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2

@27 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2

@28 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 26, i3 undef, [1 x i8] undef }, align 2

@29 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 25, i3 undef, [1 x i8] undef }, align 2

@unicode.replacement_character = internal unnamed_addr constant i21 65533, align 4

@__anon_3287 = internal unnamed_addr constant [18 x i8] c"thread {} panic: \00", align 1

@30 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8

@31 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8

@__anon_3300 = internal unnamed_addr constant [5 x i8] c"{s}\0A\00", align 1

@builtin.strip_debug_info = internal unnamed_addr constant i1 true, align 1

@32 = private unnamed_addr constant { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, align 8

@__anon_3318 = internal unnamed_addr constant [36 x i8] c"Panicked during a panic. Aborting.\0A\00", align 1

@33 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4

@34 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4

@35 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 21, [2 x i8] undef }, align 4

@36 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4

@37 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4

@38 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 22, [2 x i8] undef }, align 4

@__anon_3692 = internal unnamed_addr constant [49 x i8] c"Unable to dump stack trace: debug info stripped\0A\00", align 1

@__anon_3724 = internal unnamed_addr constant [49 x i8] c"Unable to dump stack trace: debug info stripped\0A\00", align 1

@39 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4

@40 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4

@41 = private unnamed_addr constant [22 x i8] c"OperationNotSupported\00", align 1

@42 = private unnamed_addr constant [10 x i8] c"DiskQuota\00", align 1

@43 = private unnamed_addr constant [11 x i8] c"FileTooBig\00", align 1

@44 = private unnamed_addr constant [12 x i8] c"InputOutput\00", align 1

@45 = private unnamed_addr constant [12 x i8] c"NoSpaceLeft\00", align 1

@46 = private unnamed_addr constant [11 x i8] c"DeviceBusy\00", align 1

@47 = private unnamed_addr constant [16 x i8] c"InvalidArgument\00", align 1

@48 = private unnamed_addr constant [13 x i8] c"AccessDenied\00", align 1

@49 = private unnamed_addr constant [11 x i8] c"BrokenPipe\00", align 1

@50 = private unnamed_addr constant [16 x i8] c"SystemResources\00", align 1

@51 = private unnamed_addr constant [17 x i8] c"OperationAborted\00", align 1

@52 = private unnamed_addr constant [18 x i8] c"NotOpenForWriting\00", align 1

@53 = private unnamed_addr constant [14 x i8] c"LockViolation\00", align 1

@54 = private unnamed_addr constant [11 x i8] c"WouldBlock\00", align 1

@55 = private unnamed_addr constant [22 x i8] c"ConnectionResetByPeer\00", align 1

@56 = private unnamed_addr constant [11 x i8] c"Unexpected\00", align 1

@57 = private unnamed_addr constant [9 x i8] c"Overflow\00", align 1

@58 = private unnamed_addr constant [12 x i8] c"InvalidUtf8\00", align 1

@59 = private unnamed_addr constant [25 x i8] c"Utf8ExpectedContinuation\00", align 1

@60 = private unnamed_addr constant [21 x i8] c"Utf8OverlongEncoding\00", align 1

@61 = private unnamed_addr constant [25 x i8] c"Utf8EncodesSurrogateHalf\00", align 1

@62 = private unnamed_addr constant [22 x i8] c"Utf8CodepointTooLarge\00", align 1

@63 = private unnamed_addr constant [21 x i8] c"Utf8InvalidStartByte\00", align 1

@64 = private unnamed_addr constant [15 x i8] c"TruncatedInput\00", align 1

@65 = private unnamed_addr constant [30 x i8] c"Utf8CannotEncodeSurrogateHalf\00", align 1

@66 = private unnamed_addr constant [18 x i8] c"CodepointTooLarge\00", align 1

@67 = private unnamed_addr constant [8 x i8] c"Timeout\00", align 1

@68 = private unnamed_addr constant [28 x { ptr, i64 }] [{ ptr, i64 } undef, { ptr, i64 } { ptr @41, i64 21 }, { ptr, i64 } { ptr @42, i64 9 }, { ptr, i64 } { ptr @43, i64 10 }, { ptr, i64 } { ptr @44, i64 11 }, { ptr, i64 } { ptr @45, i64 11 }, { ptr, i64 } { ptr @46, i64 10 }, { ptr, i64 } { ptr @47, i64 15 }, { ptr, i64 } { ptr @48, i64 12 }, { ptr, i64 } { ptr @49, i64 10 }, { ptr, i64 } { ptr @50, i64 15 }, { ptr, i64 } { ptr @51, i64 16 }, { ptr, i64 } { ptr @52, i64 17 }, { ptr, i64 } { ptr @53, i64 13 }, { ptr, i64 } { ptr @54, i64 10 }, { ptr, i64 } { ptr @55, i64 21 }, { ptr, i64 } { ptr @56, i64 10 }, { ptr, i64 } { ptr @57, i64 8 }, { ptr, i64 } { ptr @58, i64 11 }, { ptr, i64 } { ptr @59, i64 24 }, { ptr, i64 } { ptr @60, i64 20 }, { ptr, i64 } { ptr @61, i64 24 }, { ptr, i64 } { ptr @62, i64 21 }, { ptr, i64 } { ptr @63, i64 20 }, { ptr, i64 } { ptr @64, i64 14 }, { ptr, i64 } { ptr @65, i64 29 }, { ptr, i64 } { ptr @66, i64 17 }, { ptr, i64 } { ptr @67, i64 7 }], align 8

; Function Attrs: nounwind uwtable

define internal fastcc i16 @biggy.main() unnamed_addr #0 {

call fastcc void @debug.print__anon_972()

ret i16 0

}

; Function Attrs: nounwind uwtable

define internal fastcc void @debug.print__anon_972() unnamed_addr #0 {

%1 = alloca [16 x i8], align 8

%2 = alloca [8 x i8], align 8

%3 = alloca [16 x i8], align 8

%4 = alloca [4 x i8], align 4

%5 = alloca [4 x i8], align 4

%6 = alloca [4 x i8], align 4

%7 = alloca [4 x i8], align 4

%8 = alloca [4 x i8], align 4

call fastcc void @debug.lockStdErr()

call fastcc void @io.getStdErr(ptr sret(%fs.File) %8)

call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %8, i64 4, i1 false)

call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %6, ptr align 4 readonly nonnull %7)

call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %6, i64 4, i1 false)

call void @llvm.memcpy.p0.p0.i64(ptr align 4 %4, ptr align 4 %5, i64 4, i1 false)

%9 = getelementptr inbounds %io.Writer, ptr %3, i32 0, i32 0

store ptr %4, ptr %2, align 8

%10 = load ptr, ptr %2, align 8

%11 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %10, i32 0, i32 0

store ptr %11, ptr %9, align 8

%12 = getelementptr inbounds %io.Writer, ptr %3, i32 0, i32 1

store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %12, align 8

call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1, ptr align 8 %3, i64 16, i1 false)

%13 = call fastcc i16 @io.Writer.print__anon_2829(ptr align 8 readonly nonnull %1)

%14 = icmp eq i16 %13, 0

br i1 %14, label %16, label %17

15:

call fastcc void @debug.unlockStdErr()

ret void

16:

br label %15

17:

call fastcc void @debug.unlockStdErr()

ret void

}

; Function Attrs: nounwind uwtable

define dso_local i32 @main(i32 %0, ptr align 8 nonnull %1, ptr align 8 nonnull %2) #0 {

%4 = alloca [8 x i8], align 8

%5 = alloca [8 x i8], align 8

%6 = alloca [8 x i8], align 8

store i64 0, ptr %6, align 8

br label %19

store ptr %2, ptr %5, align 8

%8 = load i64, ptr %6, align 8

%9 = load ptr, ptr %5, align 8

%10 = getelementptr inbounds ptr, ptr %9, i64 0

%11 = insertvalue { ptr, i64 } poison, ptr %10, 0

%12 = insertvalue { ptr, i64 } %11, i64 %8, 1

%13 = sext i32 %0 to i64

store ptr %1, ptr %4, align 8

%14 = load ptr, ptr %4, align 8

%15 = getelementptr inbounds ptr, ptr %14, i64 0

%16 = insertvalue { ptr, i64 } poison, ptr %15, 0

%17 = insertvalue { ptr, i64 } %16, i64 %13, 1

store { ptr, i64 } %17, ptr getelementptr inbounds (i8, ptr @os.argv, i64 0), align 8

store { ptr, i64 } %12, ptr getelementptr inbounds (i8, ptr @os.environ, i64 0), align 8

call fastcc void @debug.maybeEnableSegfaultHandler()

call fastcc void @start.maybeIgnoreSigpipe()

%18 = call fastcc i16 @biggy.main()

ret i32 0

19:

%20 = load i64, ptr %6, align 8

%21 = getelementptr inbounds ptr, ptr %2, i64 %20

%22 = load ptr, ptr %21, align 8

%23 = icmp ne ptr %22, null

br i1 %23, label %25, label %28

24:

br label %19

25:

%26 = load i64, ptr %6, align 8

%27 = add nuw i64 %26, 1

store i64 %27, ptr %6, align 8

br label %24

28:

br label %7

}

; Function Attrs: nounwind uwtable

define internal fastcc void @debug.maybeEnableSegfaultHandler() unnamed_addr #0 {

ret void

}

; Function Attrs: nounwind uwtable

define internal fastcc void @start.maybeIgnoreSigpipe() unnamed_addr #0 {

%1 = all

Diff salvati

Testo originale

Apri file

; ModuleID = 'biggy'
source_filename = "biggy"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-macosx14.5.0-unknown"

%Target.Cpu.Feature.Set = type { [5 x i64] }
%Target.Cpu.Model = type { { ptr, i64 }, { ptr, i64 }, %Target.Cpu.Feature.Set }
%Target.Cpu = type { ptr, %Target.Cpu.Feature.Set, i6, [7 x i8] }
%SemanticVersion = type { i64, i64, i64, { ptr, i64 }, { ptr, i64 } }
%SemanticVersion.Range = type { %SemanticVersion, %SemanticVersion }
%Target.Os.LinuxVersionRange = type { %SemanticVersion.Range, %SemanticVersion }
%Target.Os.VersionRange = type { %Target.Os.LinuxVersionRange }
%Target.Os = type { %Target.Os.VersionRange, i6, [7 x i8] }
%c.darwin.Sigaction.Sigaction__union_2578 = type { ptr }
%c.darwin.Sigaction = type { %c.darwin.Sigaction.Sigaction__union_2578, i32, i32 }
%fs.File = type { i32 }
%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))" = type { %fs.File }
%io.Writer = type { ptr, ptr }
%std.Options = type { i64, i1, i2, i1, i1, i1, i1, i2, [1 x i8] }
%Target.DynamicLinker = type { [255 x i8], i8 }
%Target = type { %Target.Cpu, %Target.Os, i6, i4, %Target.DynamicLinker, [6 x i8] }
%macho.mach_header_64 = type { i32, i32, i32, i32, i32, i32, i32, i32 }
%c.darwin.os_unfair_lock = type { i32 }
%Thread.Mutex.DarwinImpl = type { %c.darwin.os_unfair_lock }
%Thread.Mutex = type { %Thread.Mutex.DarwinImpl }
%Thread.Mutex.Recursive = type { i64, i64, %Thread.Mutex, [4 x i8] }
%fmt.FormatOptions = type { { i64, i8, [7 x i8] }, { i64, i8, [7 x i8] }, i21, i2, [3 x i8] }
%"io.fixed_buffer_stream.FixedBufferStream([]u8)" = type { { ptr, i64 }, i64 }
%"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))" = type { ptr }
%Thread.PosixThreadImpl = type { ptr }
%Thread = type { %Thread.PosixThreadImpl }
%"atomic.Value(u32)" = type { i32 }
%Thread.ResetEvent.FutexImpl = type { %"atomic.Value(u32)" }
%Thread.ResetEvent = type { %Thread.ResetEvent.FutexImpl }
%Progress = type { { %Thread, i8, [7 x i8] }, i64, i64, { ptr, i64 }, { ptr, i64 }, { ptr, i64 }, { ptr, i64 }, %fs.File, %Thread.ResetEvent, i32, i16, i16, i2, i1, i1, i8, [4 x i8] }
%"atomic.Value(u8)" = type { i8 }
%builtin.StackTrace = type { i64, { ptr, i64 } }
%Progress.Node.Storage = type { i32, i32, [40 x i8] }

@builtin.zig_backend = internal unnamed_addr constant i64 2, align 8
@Target.Cpu.Feature.Set.empty = internal unnamed_addr constant %Target.Cpu.Feature.Set zeroinitializer, align 8
@Target.x86.cpu.skylake = internal unnamed_addr constant %Target.Cpu.Model { { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, %Target.Cpu.Feature.Set { [5 x i64] [i64 4703606015143248112, i64 2308508483300179218, i64 256986653737092120, i64 0, i64 0] } }, align 8
@__anon_280 = internal unnamed_addr constant [8 x i8] c"skylake\00", align 1
@builtin.cpu = internal unnamed_addr constant %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, align 8
@start.simplified_logic = internal unnamed_addr constant i1 false, align 1
@builtin.output_mode = internal unnamed_addr constant i2 0, align 1
@builtin.link_libc = internal unnamed_addr constant i1 true, align 1
@start.native_arch = internal unnamed_addr constant i6 -27, align 1
@os.argv = internal unnamed_addr global { ptr, i64 } undef, align 8
@os.environ = internal unnamed_addr global { ptr, i64 } undef, align 8
@builtin.os = internal unnamed_addr constant { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, align 8
@__anon_1669 = internal unnamed_addr constant { { ptr }, i32, i32 } { { ptr } { ptr getelementptr inbounds (i8, ptr @start.noopSigHandler, i64 0) }, i32 0, i32 0 }, align 8
@__zig_err_name_table = private unnamed_addr constant ptr @68, align 8
@builtin.mode = internal unnamed_addr constant i2 -2, align 1
@debug.runtime_safety = internal unnamed_addr constant i1 false, align 1
@debug.default_enable_segfault_handler = internal unnamed_addr constant i1 false, align 1
@log.default_level = internal unnamed_addr constant i2 0, align 1
@std.options = internal unnamed_addr constant %std.Options { i64 3, i1 false, i2 0, i1 false, i1 true, i1 false, i1 false, i2 -2, [1 x i8] undef }, align 8
@debug.enable_segfault_handler = internal unnamed_addr constant i1 false, align 1
@posix.use_libc = internal unnamed_addr constant i1 true, align 1
@c.native_os = internal unnamed_addr constant i6 10, align 1
@c.darwin.empty_sigset = internal unnamed_addr constant i32 0, align 4
@posix.empty_sigset = internal unnamed_addr constant i32 0, align 4
@builtin.abi = internal unnamed_addr constant i6 0, align 1
@builtin.object_format = internal unnamed_addr constant i4 3, align 1
@Target.DynamicLinker.none = internal unnamed_addr constant %Target.DynamicLinker { [255 x i8] undef, i8 0 }, align 1
@builtin.target = internal unnamed_addr constant { %Target.Cpu, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] }, i6, i4, %Target.DynamicLinker, [6 x i8] } { %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, i6 0, i4 3, %Target.DynamicLinker { [255 x i8] [i8 47, i8 117, i8 115, i8 114, i8 47, i8 108, i8 105, i8 98, i8 47, i8 100, i8 121, i8 108, i8 100, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef], i8 13 }, [6 x i8] undef }, align 8
@_mh_execute_header = weak_odr dso_local global %macho.mach_header_64 undef, align 4
@__anon_2157 = internal unnamed_addr constant [16 x i8] c"(msg truncated)\00", align 1
@Progress.stderr_mutex = internal unnamed_addr global %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8
@0 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@__anon_1474 = internal unnamed_addr constant [5 x i8] c"{d}\0A\00", align 1
@__anon_1704 = internal unnamed_addr constant [40 x i8] c"failed to set noop SIGPIPE handler: {s}\00", align 1
@1 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@2 = private unnamed_addr constant { { ptr, i64 }, i16, [6 x i8] } { { ptr, i64 } undef, i16 5, [6 x i8] undef }, align 8
@Thread.native_os = internal unnamed_addr constant i6 10, align 1
@builtin.single_threaded = internal unnamed_addr constant i1 false, align 1
@Thread.Mutex.Recursive.invalid_thread_id = internal unnamed_addr constant i64 -1, align 8
@Thread.Mutex.Recursive.init = internal unnamed_addr constant %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8
@Progress.global_progress = internal unnamed_addr global %Progress { { %Thread, i8, [7 x i8] } { %Thread undef, i8 0, [7 x i8] undef }, i64 undef, i64 undef, { ptr, i64 } undef, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_parents_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_storage_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_freelist_buffer, i64 0), i64 83 }, %fs.File undef, %Thread.ResetEvent zeroinitializer, i32 0, i16 0, i16 0, i2 0, i1 false, i1 false, i8 -1, [4 x i8] undef }, align 8
@3 = private unnamed_addr constant [3 x i8] c"\1B[J", align 1
@io.is_windows = internal unnamed_addr constant i1 false, align 1
@fs.File.is_windows = internal unnamed_addr constant i1 false, align 1
@4 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8
@5 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 7, [6 x i8] undef }, align 8
@6 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 14, [6 x i8] undef }, align 8
@7 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 12, [6 x i8] undef }, align 8
@8 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 2, [6 x i8] undef }, align 8
@9 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 3, [6 x i8] undef }, align 8
@10 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 4, [6 x i8] undef }, align 8
@11 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8
@12 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 8, [6 x i8] undef }, align 8
@13 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 9, [6 x i8] undef }, align 8
@14 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 15, [6 x i8] undef }, align 8
@15 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 6, [6 x i8] undef }, align 8
@fmt.max_format_args = internal unnamed_addr constant i16 32, align 2
@__anon_3237 = internal unnamed_addr constant [8 x i8] c"{ ... }\00", align 1
@debug.panic_stage = internal thread_local unnamed_addr global i64 0, align 8
@debug.panicking = internal unnamed_addr global %"atomic.Value(u8)" zeroinitializer, align 1
@Progress.node_parents_buffer = internal unnamed_addr global [83 x i8] undef, align 1
@Progress.node_storage_buffer = internal unnamed_addr global [83 x %Progress.Node.Storage] undef, align 4
@Progress.node_freelist_buffer = internal unnamed_addr global [83 x i8] undef, align 1
@Progress.is_windows = internal unnamed_addr constant i1 false, align 1
@Thread.use_pthreads = internal unnamed_addr constant i1 true, align 1
@Progress.clear = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3049, i64 0), align 8
@__anon_3049 = internal unnamed_addr constant [4 x i8] c"\1B[J\00", align 1
@posix.native_os = internal unnamed_addr constant i6 10, align 1
@fmt.ANY = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3156, i64 0), align 8
@__anon_3156 = internal unnamed_addr constant [4 x i8] c"any\00", align 1
@16 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2
@17 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2
@18 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2
@19 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2
@20 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 23, i3 undef, [1 x i8] undef }, align 2
@21 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 24, [6 x i8] undef }, align 8
@__anon_3651 = internal unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1
@22 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8
@23 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8
@posix.unexpected_error_tracing = internal unnamed_addr constant i1 false, align 1
@__anon_3758 = internal unnamed_addr constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 1
@unicode.native_endian = internal unnamed_addr constant i1 true, align 1
@mem.native_endian = internal unnamed_addr constant i1 true, align 1
@24 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2
@25 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2
@26 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2
@27 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2
@28 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 26, i3 undef, [1 x i8] undef }, align 2
@29 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 25, i3 undef, [1 x i8] undef }, align 2
@unicode.replacement_character = internal unnamed_addr constant i21 65533, align 4
@__anon_3287 = internal unnamed_addr constant [18 x i8] c"thread {} panic: \00", align 1
@30 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@31 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@__anon_3300 = internal unnamed_addr constant [5 x i8] c"{s}\0A\00", align 1
@builtin.strip_debug_info = internal unnamed_addr constant i1 true, align 1
@32 = private unnamed_addr constant { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, align 8
@__anon_3318 = internal unnamed_addr constant [36 x i8] c"Panicked during a panic. Aborting.\0A\00", align 1
@33 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@34 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@35 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 21, [2 x i8] undef }, align 4
@36 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@37 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@38 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 22, [2 x i8] undef }, align 4
@__anon_3692 = internal unnamed_addr constant [49 x i8] c"Unable to dump stack trace: debug info stripped\0A\00", align 1
@39 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@40 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@41 = private unnamed_addr constant [22 x i8] c"OperationNotSupported\00", align 1
@42 = private unnamed_addr constant [10 x i8] c"DiskQuota\00", align 1
@43 = private unnamed_addr constant [11 x i8] c"FileTooBig\00", align 1
@44 = private unnamed_addr constant [12 x i8] c"InputOutput\00", align 1
@45 = private unnamed_addr constant [12 x i8] c"NoSpaceLeft\00", align 1
@46 = private unnamed_addr constant [11 x i8] c"DeviceBusy\00", align 1
@47 = private unnamed_addr constant [16 x i8] c"InvalidArgument\00", align 1
@48 = private unnamed_addr constant [13 x i8] c"AccessDenied\00", align 1
@49 = private unnamed_addr constant [11 x i8] c"BrokenPipe\00", align 1
@50 = private unnamed_addr constant [16 x i8] c"SystemResources\00", align 1
@51 = private unnamed_addr constant [17 x i8] c"OperationAborted\00", align 1
@52 = private unnamed_addr constant [18 x i8] c"NotOpenForWriting\00", align 1
@53 = private unnamed_addr constant [14 x i8] c"LockViolation\00", align 1
@54 = private unnamed_addr constant [11 x i8] c"WouldBlock\00", align 1
@55 = private unnamed_addr constant [22 x i8] c"ConnectionResetByPeer\00", align 1
@56 = private unnamed_addr constant [11 x i8] c"Unexpected\00", align 1
@57 = private unnamed_addr constant [9 x i8] c"Overflow\00", align 1
@58 = private unnamed_addr constant [12 x i8] c"InvalidUtf8\00", align 1
@59 = private unnamed_addr constant [25 x i8] c"Utf8ExpectedContinuation\00", align 1
@60 = private unnamed_addr constant [21 x i8] c"Utf8OverlongEncoding\00", align 1
@61 = private unnamed_addr constant [25 x i8] c"Utf8EncodesSurrogateHalf\00", align 1
@62 = private unnamed_addr constant [22 x i8] c"Utf8CodepointTooLarge\00", align 1
@63 = private unnamed_addr constant [21 x i8] c"Utf8InvalidStartByte\00", align 1
@64 = private unnamed_addr constant [15 x i8] c"TruncatedInput\00", align 1
@65 = private unnamed_addr constant [30 x i8] c"Utf8CannotEncodeSurrogateHalf\00", align 1
@66 = private unnamed_addr constant [18 x i8] c"CodepointTooLarge\00", align 1
@67 = private unnamed_addr constant [8 x i8] c"Timeout\00", align 1
@68 = private unnamed_addr constant [28 x { ptr, i64 }] [{ ptr, i64 } undef, { ptr, i64 } { ptr @41, i64 21 }, { ptr, i64 } { ptr @42, i64 9 }, { ptr, i64 } { ptr @43, i64 10 }, { ptr, i64 } { ptr @44, i64 11 }, { ptr, i64 } { ptr @45, i64 11 }, { ptr, i64 } { ptr @46, i64 10 }, { ptr, i64 } { ptr @47, i64 15 }, { ptr, i64 } { ptr @48, i64 12 }, { ptr, i64 } { ptr @49, i64 10 }, { ptr, i64 } { ptr @50, i64 15 }, { ptr, i64 } { ptr @51, i64 16 }, { ptr, i64 } { ptr @52, i64 17 }, { ptr, i64 } { ptr @53, i64 13 }, { ptr, i64 } { ptr @54, i64 10 }, { ptr, i64 } { ptr @55, i64 21 }, { ptr, i64 } { ptr @56, i64 10 }, { ptr, i64 } { ptr @57, i64 8 }, { ptr, i64 } { ptr @58, i64 11 }, { ptr, i64 } { ptr @59, i64 24 }, { ptr, i64 } { ptr @60, i64 20 }, { ptr, i64 } { ptr @61, i64 24 }, { ptr, i64 } { ptr @62, i64 21 }, { ptr, i64 } { ptr @63, i64 20 }, { ptr, i64 } { ptr @64, i64 14 }, { ptr, i64 } { ptr @65, i64 29 }, { ptr, i64 } { ptr @66, i64 17 }, { ptr, i64 } { ptr @67, i64 7 }], align 8

; Function Attrs: nounwind uwtable
define internal fastcc i16 @biggy.main() unnamed_addr #0 {
0:
  call fastcc void @debug.print__anon_972()
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.print__anon_972() unnamed_addr #0 {
0:
  %1 = alloca [16 x i8], align 8
  %2 = alloca [8 x i8], align 8
  %3 = alloca [16 x i8], align 8
  %4 = alloca [4 x i8], align 4
  %5 = alloca [4 x i8], align 4
  %6 = alloca [4 x i8], align 4
  %7 = alloca [4 x i8], align 4
  %8 = alloca [4 x i8], align 4
  call fastcc void @debug.lockStdErr()
  call fastcc void @io.getStdErr(ptr sret(%fs.File) %8)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %8, i64 4, i1 false)
  call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %6, ptr align 4 readonly nonnull %7)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %6, i64 4, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %4, ptr align 4 %5, i64 4, i1 false)
  %9 = getelementptr inbounds %io.Writer, ptr %3, i32 0, i32 0
  store ptr %4, ptr %2, align 8
  %10 = load ptr, ptr %2, align 8
  %11 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %10, i32 0, i32 0
  store ptr %11, ptr %9, align 8
  %12 = getelementptr inbounds %io.Writer, ptr %3, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %12, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1, ptr align 8 %3, i64 16, i1 false)
  %13 = call fastcc i16 @io.Writer.print__anon_2829(ptr align 8 readonly nonnull %1)
  %14 = icmp eq i16 %13, 0
  br i1 %14, label %16, label %17

15:
  call fastcc void @debug.unlockStdErr()
  ret void

16:
  br label %15

17:
  call fastcc void @debug.unlockStdErr()
  ret void
}

; Function Attrs: nounwind uwtable
define dso_local i32 @main(i32 %0, ptr align 8 nonnull %1, ptr align 8 nonnull %2) #0 {
3:
  %4 = alloca [8 x i8], align 8
  %5 = alloca [8 x i8], align 8
  %6 = alloca [8 x i8], align 8
  store i64 0, ptr %6, align 8
  br label %19

7:
  store ptr %2, ptr %5, align 8
  %8 = load i64, ptr %6, align 8
  %9 = load ptr, ptr %5, align 8
  %10 = getelementptr inbounds ptr, ptr %9, i64 0
  %11 = insertvalue { ptr, i64 } poison, ptr %10, 0
  %12 = insertvalue { ptr, i64 } %11, i64 %8, 1
  %13 = sext i32 %0 to i64
  store ptr %1, ptr %4, align 8
  %14 = load ptr, ptr %4, align 8
  %15 = getelementptr inbounds ptr, ptr %14, i64 0
  %16 = insertvalue { ptr, i64 } poison, ptr %15, 0
  %17 = insertvalue { ptr, i64 } %16, i64 %13, 1
  store { ptr, i64 } %17, ptr getelementptr inbounds (i8, ptr @os.argv, i64 0), align 8
  store { ptr, i64 } %12, ptr getelementptr inbounds (i8, ptr @os.environ, i64 0), align 8
  call fastcc void @debug.maybeEnableSegfaultHandler()
  call fastcc void @start.maybeIgnoreSigpipe()
  %18 = call fastcc i16 @biggy.main()
  ret i32 0

19:
  %20 = load i64, ptr %6, align 8
  %21 = getelementptr inbounds ptr, ptr %2, i64 %20
  %22 = load ptr, ptr %21, align 8
  %23 = icmp ne ptr %22, null
  br i1 %23, label %25, label %28

24:
  br label %19

25:
  %26 = load i64, ptr %6, align 8
  %27 = add nuw i64 %26, 1
  store i64 %27, ptr %6, align 8
  br label %24

28:
  br label %7
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.maybeEnableSegfaultHandler() unnamed_addr #0 {
0:
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @start.maybeIgnoreSigpipe() unnamed_addr #0 {
0:
  %1 = alloca [16 x i8], align 8
  %2 = call fastcc i16 @posix.sigaction(i6 13, ptr align 8 noalias readonly getelementptr inbounds (i8, ptr @__anon_1669, i64 0), ptr align 8 noalias null)
  %3 = icmp eq i16 %2, 0
  br i1 %3, label %5, label %6

4:
  ret void

5:
  br label %4

6:
  %7 = load ptr, ptr @__zig_err_name_table
  %8 = getelementptr inbounds { ptr, i64 }, ptr %7, i16 %2
  %9 = load { ptr, i64 }, ptr %8
  %10 = getelementptr inbounds { { ptr, i64 } }, ptr %1, i32 0, i32 0
  store { ptr, i64 } %9, ptr %10, align 8
  call fastcc void @debug.panic__anon_2624(ptr align 8 readonly nonnull %1)
  unreachable
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @posix.sigaction(i6 %0, ptr align 8 noalias readonly %1, ptr align 8 noalias %2) unnamed_addr #0 {
3:
  %4 = zext i6 %0 to i32
  %5 = call i32 @sigaction(i32 %4, ptr align 8 noalias readonly %1, ptr align 8 noalias %2)
  %6 = call fastcc i16 @posix.errno__anon_3210(i32 %5)
  switch i16 %6, label %7 [
    i16 0, label %8
    i16 22, label %9
    i16 78, label %9
  ]

7:
  unreachable

8:
  ret i16 0

9:
  ret i16 1
}

; Function Attrs: nounwind uwtable
define internal void @start.noopSigHandler(i32 %0) unnamed_addr #0 {
1:
  ret void
}

; Function Attrs: noreturn nounwind uwtable cold
define internal fastcc void @debug.panic__anon_2624(ptr align 8 readonly nonnull %0) unnamed_addr #1 {
1:
  %2 = alloca [16 x i8], align 8
  %3 = call ptr @llvm.returnaddress(i32 0)
  %4 = ptrtoint ptr %3 to i64
  %5 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %2, i32 0, i32 0
  store i64 %4, ptr %5, align 8
  %6 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %2, i32 0, i32 1
  store i8 1, ptr %6
  call fastcc void @debug.panicExtra__anon_3213(ptr align 8 null, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %0)
  unreachable
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.lockStdErr() unnamed_addr #0 {
0:
  call fastcc void @Progress.lockStdErr()
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @io.getStdErr(ptr noalias sret(%fs.File) nonnull %0) unnamed_addr #0 {
1:
  %2 = getelementptr inbounds %fs.File, ptr %0, i32 0, i32 0
  %3 = call fastcc i32 @io.getStdErrHandle()
  store i32 %3, ptr %2, align 4
  ret void
}

; Function Attrs: nounwind willreturn nofree nocallback memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly %0, ptr noalias nocapture readonly %1, i64 %2, i1 immarg %3) #2

; Function Attrs: nounwind uwtable
define internal fastcc void @fs.File.writer(ptr noalias sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") nonnull %0, ptr align 4 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %0, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %3, ptr align 4 %1, i64 4, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn"(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %7 = insertvalue { ptr, i64 } %6, i64 %3, 1
  %8 = extractvalue { ptr, i64 } %7, 0
  %9 = extractvalue { ptr, i64 } %7, 1
  call fastcc void @fs.File.write(ptr sret({ i64, i16, [6 x i8] }) %5, ptr align 4 readonly nonnull %1, ptr align 1 readonly nonnull %8, i64 %9)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 %5, i64 16, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.print__anon_2829(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = call fastcc i16 @fmt.format__anon_3278(ptr align 8 readonly nonnull %0)
  ret i16 %2
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.unlockStdErr() unnamed_addr #0 {
0:
  call fastcc void @Progress.unlockStdErr()
  ret void
}

; Function Attrs: nounwind uwtable
declare i32 @sigaction(i32 %0, ptr align 8 noalias readonly %1, ptr align 8 noalias %2) #0

; Function Attrs: nounwind uwtable
define internal fastcc i16 @posix.errno__anon_3210(i32 %0) unnamed_addr #0 {
1:
  %2 = icmp eq i32 %0, -1
  br i1 %2, label %5, label %9

3:
  %4 = phi i16 [ %8, %5 ], [ 0, %9 ]
  ret i16 %4

5:
  %6 = call ptr @__error()
  %7 = load i32, ptr %6, align 4
  %8 = trunc i32 %7 to i16
  br label %3

9:
  br label %3
}

; Function Attrs: nounwind willreturn nofree nosync nocallback memory(none)
declare ptr @llvm.returnaddress(i32 immarg %0) #3

; Function Attrs: noreturn nounwind uwtable cold
define internal fastcc void @debug.panicExtra__anon_3213(ptr align 8 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2) unnamed_addr #1 {
3:
  %4 = alloca [16 x i8], align 8
  %5 = alloca [24 x i8], align 8
  %6 = alloca [4111 x i8], align 1
  call void @llvm.memset.p0.i64(ptr align 1 %6, i8 undef, i64 4111, i1 false)
  %7 = getelementptr inbounds i8, ptr %6, i64 0
  %8 = getelementptr inbounds [4096 x i8], ptr %7, i64 0, i64 0
  %9 = insertvalue { ptr, i64 } poison, ptr %8, 0
  %10 = insertvalue { ptr, i64 } %9, i64 4096, 1
  %11 = extractvalue { ptr, i64 } %10, 0
  %12 = extractvalue { ptr, i64 } %10, 1
  call fastcc void @fmt.bufPrint__anon_3279(ptr sret({ { ptr, i64 }, i16, [6 x i8] }) %5, ptr align 1 nonnull %11, i64 %12, ptr align 8 readonly nonnull %2)
  %13 = getelementptr inbounds { { ptr, i64 }, i16, [6 x i8] }, ptr %5, i32 0, i32 1
  %14 = load i16, ptr %13
  %15 = icmp eq i16 %14, 0
  br i1 %15, label %21, label %24

16:
  %17 = phi { ptr, i64 } [ %23, %21 ], [ %32, %28 ]
  store { ptr, i64 } %17, ptr %4, align 8
  %18 = load { ptr, i64 }, ptr %4, align 8
  %19 = extractvalue { ptr, i64 } %18, 0
  %20 = extractvalue { ptr, i64 } %18, 1
  call fastcc void @builtin.default_panic(ptr align 1 readonly nonnull %19, i64 %20, ptr align 8 %0, ptr align 8 readonly nonnull %1)
  unreachable

21:
  %22 = getelementptr inbounds { { ptr, i64 }, i16, [6 x i8] }, ptr %5, i32 0, i32 0
  %23 = load { ptr, i64 }, ptr %22, align 8
  br label %16

24:
  %25 = getelementptr inbounds { { ptr, i64 }, i16, [6 x i8] }, ptr %5, i32 0, i32 1
  %26 = load i16, ptr %25
  switch i16 %26, label %27 [
    i16 5, label %28
  ]

27:
  unreachable

28:
  %29 = getelementptr inbounds i8, ptr %6, i64 4096
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %29, ptr align 1 getelementptr inbounds (i8, ptr @__anon_2157, i64 0), i64 15, i1 false)
  %30 = getelementptr inbounds [4111 x i8], ptr %6, i64 0, i64 0
  %31 = insertvalue { ptr, i64 } poison, ptr %30, 0
  %32 = insertvalue { ptr, i64 } %31, i64 4111, 1
  br label %16
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Progress.lockStdErr() unnamed_addr #0 {
0:
  call fastcc void @Thread.Mutex.Recursive.lock(ptr align 8 nonnull getelementptr inbounds (i8, ptr @Progress.stderr_mutex, i64 0))
  %1 = call fastcc i16 @Progress.clearWrittenWithEscapeCodes()
  %2 = icmp eq i16 %1, 0
  br i1 %2, label %4, label %5

3:
  ret void

4:
  br label %3

5:
  br label %3
}

; Function Attrs: nounwind uwtable
define internal fastcc i32 @io.getStdErrHandle() unnamed_addr #0 {
0:
  ret i32 2
}

; Function Attrs: nounwind uwtable
define internal fastcc void @fs.File.write(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 4 readonly nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %7 = insertvalue { ptr, i64 } %6, i64 %3, 1
  %8 = getelementptr inbounds %fs.File, ptr %1, i32 0, i32 0
  %9 = load i32, ptr %8, align 4
  %10 = extractvalue { ptr, i64 } %7, 0
  %11 = extractvalue { ptr, i64 } %7, 1
  call fastcc void @posix.write(ptr sret({ i64, i16, [6 x i8] }) %5, i32 %9, ptr align 1 readonly nonnull %10, i64 %11)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 %5, i64 16, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_3278(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [16 x i8], align 8
  %3 = call fastcc i16 @fmt.formatType__anon_3567(ptr align 8 readonly nonnull @0, ptr align 8 readonly nonnull %0, i64 3)
  %4 = icmp ne i16 %3, 0
  br i1 %4, label %5, label %6

5:
  ret i16 %3

6:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %0, i64 16, i1 false)
  %7 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_1474, i64 3), i64 1 }, 0
  %8 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_1474, i64 3), i64 1 }, 1
  %9 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %2, ptr align 1 readonly nonnull %7, i64 %8)
  %10 = icmp ne i16 %9, 0
  br i1 %10, label %11, label %12

11:
  ret i16 %9

12:
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Progress.unlockStdErr() unnamed_addr #0 {
0:
  call fastcc void @Thread.Mutex.Recursive.unlock(ptr align 8 nonnull getelementptr inbounds (i8, ptr @Progress.stderr_mutex, i64 0))
  ret void
}

; Function Attrs: nounwind uwtable
declare ptr @__error() #0

; Function Attrs: nounwind willreturn nofree nocallback memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly %0, i8 %1, i64 %2, i1 immarg %3) #4

; Function Attrs: nounwind uwtable
define internal fastcc void @fmt.bufPrint__anon_3279(ptr noalias sret({ { ptr, i64 }, i16, [6 x i8] }) nonnull %0, ptr align 1 nonnull %1, i64 %2, ptr align 8 readonly nonnull %3) unnamed_addr #0 {
4:
  %5 = alloca [8 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = alloca [8 x i8], align 8
  %8 = alloca [8 x i8], align 8
  %9 = alloca [24 x i8], align 8
  %10 = alloca [24 x i8], align 8
  %11 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %12 = insertvalue { ptr, i64 } %11, i64 %2, 1
  %13 = extractvalue { ptr, i64 } %12, 0
  %14 = extractvalue { ptr, i64 } %12, 1
  call fastcc void @io.fixed_buffer_stream.fixedBufferStream__anon_3601(ptr sret(%"io.fixed_buffer_stream.FixedBufferStream([]u8)") %9, ptr align 1 nonnull %13, i64 %14)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %10, ptr align 8 %9, i64 24, i1 false)
  call fastcc void @"io.fixed_buffer_stream.FixedBufferStream([]u8).writer"(ptr sret(%"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))") %8, ptr align 8 nonnull %10)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %7, ptr align 8 %8, i64 8, i1 false)
  %15 = getelementptr inbounds %io.Writer, ptr %6, i32 0, i32 0
  store ptr %7, ptr %5, align 8
  %16 = load ptr, ptr %5, align 8
  %17 = getelementptr inbounds %"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))", ptr %16, i32 0, i32 0
  store ptr %17, ptr %15, align 8
  %18 = getelementptr inbounds %io.Writer, ptr %6, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write')).typeErasedWriteFn", i64 0), ptr %18, align 8
  %19 = call fastcc i16 @fmt.format__anon_3616(ptr align 8 readonly nonnull %6, ptr align 8 readonly nonnull %3)
  %20 = icmp eq i16 %19, 0
  br i1 %20, label %25, label %26

21:
  %22 = call fastcc { ptr, i64 } @"io.fixed_buffer_stream.FixedBufferStream([]u8).getWritten"(ptr align 8 readonly nonnull %10)
  %23 = getelementptr inbounds { { ptr, i64 }, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %23, align 2
  %24 = getelementptr inbounds { { ptr, i64 }, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  store { ptr, i64 } %22, ptr %24, align 8
  ret void

25:
  br label %21

26:
  switch i16 %19, label %27 [
    i16 5, label %28
  ]

27:
  unreachable

28:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @2, i64 24, i1 false)
  ret void
}

; Function Attrs: noreturn nounwind uwtable cold
define internal fastcc void @builtin.default_panic(ptr align 1 readonly nonnull %0, i64 %1, ptr align 8 %2, ptr align 8 readonly nonnull %3) unnamed_addr #1 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = insertvalue { ptr, i64 } poison, ptr %0, 0
  %7 = insertvalue { ptr, i64 } %6, i64 %1, 1
  %8 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %3, i32 0, i32 1
  %9 = load i8, ptr %8
  %10 = icmp ne i8 %9, 0
  br i1 %10, label %17, label %20

11:
  %12 = phi i64 [ %19, %17 ], [ %22, %20 ]
  %13 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %5, i32 0, i32 0
  store i64 %12, ptr %13, align 8
  %14 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %5, i32 0, i32 1
  store i8 1, ptr %14
  %15 = extractvalue { ptr, i64 } %7, 0
  %16 = extractvalue { ptr, i64 } %7, 1
  call fastcc void @debug.panicImpl(ptr align 8 readonly %2, ptr align 8 readonly nonnull %5, ptr align 1 readonly nonnull %15, i64 %16)
  unreachable

17:
  %18 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %3, i32 0, i32 0
  %19 = load i64, ptr %18, align 8
  br label %11

20:
  %21 = call ptr @llvm.returnaddress(i32 0)
  %22 = ptrtoint ptr %21 to i64
  br label %11
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.Recursive.lock(ptr align 8 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  %3 = alloca [8 x i8], align 8
  %4 = alloca [8 x i8], align 8
  %5 = alloca [8 x i8], align 8
  %6 = call fastcc i64 @Thread.getCurrentId()
  store ptr %0, ptr %5, align 8
  %7 = load ptr, ptr %5, align 8
  %8 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %7, i32 0, i32 0
  %9 = load atomic i64, ptr %8 unordered, align 8
  %10 = icmp ne i64 %9, %6
  br i1 %10, label %16, label %24

11:
  store ptr %0, ptr %2, align 8
  %12 = load ptr, ptr %2, align 8
  %13 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %12, i32 0, i32 1
  %14 = load i64, ptr %13, align 8
  %15 = add nuw i64 %14, 1
  store i64 %15, ptr %13, align 8
  ret void

16:
  store ptr %0, ptr %4, align 8
  %17 = load ptr, ptr %4, align 8
  %18 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %17, i32 0, i32 2
  call fastcc void @Thread.Mutex.lock(ptr align 4 nonnull %18)
  %19 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %0, i32 0, i32 1
  %20 = load i64, ptr %19, align 8
  %21 = icmp eq i64 %20, 0
  call fastcc void @debug.assert(i1 %21)
  store ptr %0, ptr %3, align 8
  %22 = load ptr, ptr %3, align 8
  %23 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %22, i32 0, i32 0
  store atomic i64 %6, ptr %23 unordered, align 8
  br label %11

24:
  br label %11
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @Progress.clearWrittenWithEscapeCodes() unnamed_addr #0 {
0:
  %1 = alloca [16 x i8], align 8
  %2 = alloca [16 x i8], align 8
  %3 = alloca [8 x i8], align 8
  %4 = getelementptr inbounds %Progress, ptr getelementptr inbounds (i8, ptr @Progress.global_progress, i64 0), i32 0, i32 14
  %5 = load i1, ptr %4, align 1
  %6 = xor i1 %5, true
  br i1 %6, label %27, label %28

7:
  store i64 0, ptr %3, align 8
  %8 = getelementptr inbounds %Progress, ptr getelementptr inbounds (i8, ptr @Progress.global_progress, i64 0), i32 0, i32 3
  %9 = load { ptr, i64 }, ptr %8, align 8
  store { ptr, i64 } %9, ptr %2, align 8
  %10 = load i64, ptr %3, align 8
  %11 = load { ptr, i64 }, ptr %2, align 8
  %12 = extractvalue { ptr, i64 } %11, 0
  %13 = getelementptr inbounds i8, ptr %12, i64 %10
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %13, ptr align 1 @3, i64 3, i1 false)
  %14 = load i64, ptr %3, align 8
  %15 = add nuw i64 %14, 3
  store i64 %15, ptr %3, align 8
  store i1 false, ptr getelementptr inbounds (i8, ptr @Progress.global_progress, i64 114), align 1
  %16 = load i64, ptr %3, align 8
  %17 = load { ptr, i64 }, ptr %2, align 8
  %18 = extractvalue { ptr, i64 } %17, 0
  %19 = getelementptr inbounds i8, ptr %18, i64 0
  %20 = insertvalue { ptr, i64 } poison, ptr %19, 0
  %21 = insertvalue { ptr, i64 } %20, i64 %16, 1
  store { ptr, i64 } %21, ptr %1, align 8
  %22 = load { ptr, i64 }, ptr %1, align 8
  %23 = extractvalue { ptr, i64 } %22, 0
  %24 = extractvalue { ptr, i64 } %22, 1
  %25 = call fastcc i16 @Progress.write(ptr align 1 readonly nonnull %23, i64 %24)
  %26 = icmp ne i16 %25, 0
  br i1 %26, label %29, label %30

27:
  ret i16 0

28:
  br label %7

29:
  ret i16 %25

30:
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc void @posix.write(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, i32 %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %6 = insertvalue { ptr, i64 } %5, i64 %3, 1
  %7 = extractvalue { ptr, i64 } %6, 1
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %10, label %11

9:
  br label %12

10:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @4, i64 16, i1 false)
  ret void

11:
  br label %9

12:
  %13 = extractvalue { ptr, i64 } %6, 0
  %14 = extractvalue { ptr, i64 } %6, 1
  %15 = call i64 @llvm.umin.i64(i64 2147483647, i64 %14)
  %16 = trunc i64 %15 to i31
  %17 = zext i31 %16 to i64
  %18 = call i64 @write(i32 %1, ptr align 1 readonly nonnull %13, i64 %17)
  %19 = call fastcc i16 @posix.errno__anon_3734(i64 %18)
  switch i16 %19, label %21 [
    i16 0, label %25
    i16 4, label %28
    i16 22, label %29
    i16 14, label %30
    i16 35, label %31
    i16 9, label %32
    i16 39, label %33
    i16 69, label %34
    i16 27, label %35
    i16 5, label %36
    i16 28, label %37
    i16 1, label %38
    i16 32, label %39
    i16 54, label %40
    i16 16, label %41
  ]

20:
  br label %12

21:
  %22 = call fastcc i16 @posix.unexpectedErrno(i16 %19)
  %23 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 %22, ptr %23, align 2
  %24 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  ret void

25:
  %26 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %26, align 2
  %27 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  store i64 %18, ptr %27, align 8
  ret void

28:
  br label %20

29:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @5, i64 16, i1 false)
  ret void

30:
  unreachable

31:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @6, i64 16, i1 false)
  ret void

32:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @7, i64 16, i1 false)
  ret void

33:
  unreachable

34:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @8, i64 16, i1 false)
  ret void

35:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @9, i64 16, i1 false)
  ret void

36:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @10, i64 16, i1 false)
  ret void

37:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @11, i64 16, i1 false)
  ret void

38:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @12, i64 16, i1 false)
  ret void

39:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @13, i64 16, i1 false)
  ret void

40:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @14, i64 16, i1 false)
  ret void

41:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @15, i64 16, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatType__anon_3567(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = call fastcc i16 @fmt.formatValue__anon_3979(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1)
  ret i16 %4
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [16 x i8], align 8
  %5 = alloca [16 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = alloca [16 x i8], align 8
  %8 = alloca [8 x i8], align 8
  %9 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %10 = insertvalue { ptr, i64 } %9, i64 %2, 1
  store i64 0, ptr %8, align 8
  br label %12

11:
  ret i16 0

12:
  %13 = load i64, ptr %8, align 8
  %14 = extractvalue { ptr, i64 } %10, 1
  %15 = icmp ne i64 %13, %14
  br i1 %15, label %17, label %32

16:
  br label %12

17:
  %18 = load i64, ptr %8, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %7, ptr align 8 %0, i64 16, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %6, ptr align 8 %7, i64 16, i1 false)
  store { ptr, i64 } %10, ptr %5, align 8
  %19 = load i64, ptr %8, align 8
  %20 = load { ptr, i64 }, ptr %5, align 8
  %21 = extractvalue { ptr, i64 } %20, 0
  %22 = getelementptr inbounds i8, ptr %21, i64 %19
  %23 = extractvalue { ptr, i64 } %20, 1
  %24 = sub nuw i64 %23, %19
  %25 = insertvalue { ptr, i64 } poison, ptr %22, 0
  %26 = insertvalue { ptr, i64 } %25, i64 %24, 1
  %27 = extractvalue { ptr, i64 } %26, 0
  %28 = extractvalue { ptr, i64 } %26, 1
  call fastcc void @io.Writer.write(ptr sret({ i64, i16, [6 x i8] }) %4, ptr align 8 readonly nonnull %6, ptr align 1 readonly nonnull %27, i64 %28)
  %29 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 1
  %30 = load i16, ptr %29
  %31 = icmp ne i16 %30, 0
  br i1 %31, label %33, label %36

32:
  br label %11

33:
  %34 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 1
  %35 = load i16, ptr %34
  ret i16 %35

36:
  %37 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 0
  %38 = load i64, ptr %37, align 8
  %39 = add nuw i64 %18, %38
  store i64 %39, ptr %8, align 8
  br label %16
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.Recursive.unlock(ptr align 8 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  %3 = alloca [8 x i8], align 8
  %4 = alloca [8 x i8], align 8
  store ptr %0, ptr %4, align 8
  %5 = load ptr, ptr %4, align 8
  %6 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %5, i32 0, i32 1
  %7 = load i64, ptr %6, align 8
  %8 = sub nuw i64 %7, 1
  store i64 %8, ptr %6, align 8
  %9 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %0, i32 0, i32 1
  %10 = load i64, ptr %9, align 8
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %13, label %18

12:
  ret void

13:
  store ptr %0, ptr %3, align 8
  %14 = load ptr, ptr %3, align 8
  %15 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %14, i32 0, i32 0
  store atomic i64 -1, ptr %15 unordered, align 8
  store ptr %0, ptr %2, align 8
  %16 = load ptr, ptr %2, align 8
  %17 = getelementptr inbounds %Thread.Mutex.Recursive, ptr %16, i32 0, i32 2
  call fastcc void @Thread.Mutex.unlock(ptr align 4 nonnull %17)
  br label %12

18:
  br label %12
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_3616(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = alloca [16 x i8], align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %3, ptr align 8 %0, i64 16, i1 false)
  %4 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_1704, i64 0), i64 36 }, 0
  %5 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_1704, i64 0), i64 36 }, 1
  %6 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %3, ptr align 1 readonly nonnull %4, i64 %5)
  %7 = icmp ne i16 %6, 0
  br i1 %7, label %8, label %9

8:
  ret i16 %6

9:
  %10 = getelementptr inbounds { { ptr, i64 } }, ptr %1, i32 0, i32 0
  %11 = load { ptr, i64 }, ptr %10, align 8
  %12 = extractvalue { ptr, i64 } %11, 0
  %13 = extractvalue { ptr, i64 } %11, 1
  %14 = call fastcc i16 @fmt.formatType__anon_3617(ptr align 1 readonly nonnull %12, i64 %13, ptr align 8 readonly nonnull @1, ptr align 8 readonly nonnull %0, i64 3)
  %15 = icmp ne i16 %14, 0
  br i1 %15, label %16, label %17

16:
  ret i16 %14

17:
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatType__anon_3617(ptr align 1 readonly nonnull %0, i64 %1, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %3, i64 %4) unnamed_addr #0 {
5:
  %6 = alloca [16 x i8], align 8
  %7 = alloca [16 x i8], align 8
  %8 = insertvalue { ptr, i64 } poison, ptr %0, 0
  %9 = insertvalue { ptr, i64 } %8, i64 %1, 1
  %10 = icmp eq i64 %4, 0
  br i1 %10, label %16, label %20

11:
  store { ptr, i64 } %9, ptr %6, align 8
  %12 = load { ptr, i64 }, ptr %6, align 8
  %13 = extractvalue { ptr, i64 } %12, 0
  %14 = extractvalue { ptr, i64 } %12, 1
  %15 = call fastcc i16 @fmt.formatBuf__anon_3980(ptr align 1 readonly nonnull %13, i64 %14, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %3)
  ret i16 %15

16:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %7, ptr align 8 %3, i64 16, i1 false)
  %17 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3237, i64 0), i64 7 }, 0
  %18 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3237, i64 0), i64 7 }, 1
  %19 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %7, ptr align 1 readonly nonnull %17, i64 %18)
  ret i16 %19

20:
  br label %11
}

; Function Attrs: nounwind uwtable
define internal fastcc void @io.fixed_buffer_stream.fixedBufferStream__anon_3601(ptr noalias sret(%"io.fixed_buffer_stream.FixedBufferStream([]u8)") nonnull %0, ptr align 1 nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %5 = insertvalue { ptr, i64 } %4, i64 %2, 1
  %6 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %0, i32 0, i32 0
  store { ptr, i64 } %5, ptr %6, align 8
  %7 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %0, i32 0, i32 1
  store i64 0, ptr %7, align 8
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @"io.fixed_buffer_stream.FixedBufferStream([]u8).writer"(ptr noalias sret(%"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))") nonnull %0, ptr align 8 nonnull %1) unnamed_addr #0 {
2:
  %3 = getelementptr inbounds %"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write'))", ptr %0, i32 0, i32 0
  store ptr %1, ptr %3, align 8
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @"io.GenericWriter(*io.fixed_buffer_stream.FixedBufferStream([]u8),error{NoSpaceLeft},(function 'write')).typeErasedWriteFn"(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %7 = insertvalue { ptr, i64 } %6, i64 %3, 1
  %8 = load ptr, ptr %1, align 8
  %9 = extractvalue { ptr, i64 } %7, 0
  %10 = extractvalue { ptr, i64 } %7, 1
  call fastcc void @"io.fixed_buffer_stream.FixedBufferStream([]u8).write"(ptr sret({ i64, i16, [6 x i8] }) %5, ptr align 8 nonnull %8, ptr align 1 readonly nonnull %9, i64 %10)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 %5, i64 16, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc { ptr, i64 } @"io.fixed_buffer_stream.FixedBufferStream([]u8).getWritten"(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [24 x i8], align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %0, i64 24, i1 false)
  %3 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %2, i32 0, i32 0
  %4 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %0, i32 0, i32 1
  %5 = load i64, ptr %4, align 8
  %6 = load { ptr, i64 }, ptr %3, align 8
  %7 = extractvalue { ptr, i64 } %6, 0
  %8 = getelementptr inbounds i8, ptr %7, i64 0
  %9 = insertvalue { ptr, i64 } poison, ptr %8, 0
  %10 = insertvalue { ptr, i64 } %9, i64 %5, 1
  ret { ptr, i64 } %10
}

; Function Attrs: noreturn nounwind uwtable cold
define internal fastcc void @debug.panicImpl(ptr align 8 readonly %0, ptr align 8 readonly nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #1 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = alloca [8 x i8], align 8
  %7 = alloca [16 x i8], align 8
  %8 = alloca [4 x i8], align 4
  %9 = alloca [4 x i8], align 4
  %10 = alloca [4 x i8], align 4
  %11 = alloca [4 x i8], align 4
  %12 = alloca [4 x i8], align 4
  %13 = alloca [16 x i8], align 8
  %14 = alloca [8 x i8], align 8
  %15 = alloca [16 x i8], align 8
  %16 = alloca [4 x i8], align 4
  %17 = alloca [16 x i8], align 8
  %18 = alloca [16 x i8], align 8
  %19 = alloca [8 x i8], align 8
  %20 = alloca [16 x i8], align 8
  %21 = alloca [4 x i8], align 4
  %22 = alloca [8 x i8], align 8
  %23 = alloca [4 x i8], align 4
  %24 = alloca [4 x i8], align 4
  %25 = alloca [4 x i8], align 4
  %26 = alloca [4 x i8], align 4
  %27 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %28 = insertvalue { ptr, i64 } %27, i64 %3, 1
  %29 = load i64, ptr getelementptr inbounds (i8, ptr @debug.panic_stage, i64 0), align 8
  switch i64 %29, label %31 [
    i64 0, label %32
    i64 1, label %59
  ]

30:
  call fastcc void @posix.abort()
  unreachable

31:
  br label %30

32:
  store i64 1, ptr getelementptr inbounds (i8, ptr @debug.panic_stage, i64 0), align 8
  %33 = atomicrmw add ptr getelementptr inbounds (i8, ptr @debug.panicking, i64 0), i8 1 seq_cst, align 1
  call fastcc void @debug.lockStdErr()
  call fastcc void @io.getStdErr(ptr sret(%fs.File) %26)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %25, ptr align 4 %26, i64 4, i1 false)
  call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %24, ptr align 4 readonly nonnull %25)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %23, ptr align 4 %24, i64 4, i1 false)
  %34 = call fastcc i64 @Thread.getCurrentId()
  %35 = getelementptr inbounds { i64 }, ptr %22, i32 0, i32 0
  store i64 %34, ptr %35, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %23, i64 4, i1 false)
  %36 = getelementptr inbounds %io.Writer, ptr %20, i32 0, i32 0
  store ptr %21, ptr %19, align 8
  %37 = load ptr, ptr %19, align 8
  %38 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %37, i32 0, i32 0
  store ptr %38, ptr %36, align 8
  %39 = getelementptr inbounds %io.Writer, ptr %20, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %39, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %18, ptr align 8 %20, i64 16, i1 false)
  %40 = call fastcc i16 @io.Writer.print__anon_4004(ptr align 8 readonly nonnull %18, ptr align 8 readonly nonnull %22)
  %41 = icmp eq i16 %40, 0
  br i1 %41, label %50, label %51

42:
  %43 = getelementptr inbounds { { ptr, i64 } }, ptr %17, i32 0, i32 0
  store { ptr, i64 } %28, ptr %43, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %16, ptr align 4 %23, i64 4, i1 false)
  %44 = getelementptr inbounds %io.Writer, ptr %15, i32 0, i32 0
  store ptr %16, ptr %14, align 8
  %45 = load ptr, ptr %14, align 8
  %46 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %45, i32 0, i32 0
  store ptr %46, ptr %44, align 8
  %47 = getelementptr inbounds %io.Writer, ptr %15, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %47, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %13, ptr align 8 %15, i64 16, i1 false)
  %48 = call fastcc i16 @io.Writer.print__anon_4005(ptr align 8 readonly nonnull %13, ptr align 8 readonly nonnull %17)
  %49 = icmp eq i16 %48, 0
  br i1 %49, label %54, label %55

50:
  br label %42

51:
  call fastcc void @posix.abort()
  unreachable

52:
  %53 = icmp ne ptr %0, null
  br i1 %53, label %57, label %58

54:
  br label %52

55:
  call fastcc void @posix.abort()
  unreachable

56:
  call fastcc void @debug.dumpCurrentStackTrace(ptr align 8 readonly nonnull %1)
  call fastcc void @debug.unlockStdErr()
  call fastcc void @debug.waitForOtherThreadToFinishPanicking()
  br label %30

57:
  call fastcc void @debug.dumpStackTrace(ptr align 8 readonly nonnull %0)
  br label %56

58:
  br label %56

59:
  store i64 2, ptr getelementptr inbounds (i8, ptr @debug.panic_stage, i64 0), align 8
  call fastcc void @io.getStdErr(ptr sret(%fs.File) %12)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %12, i64 4, i1 false)
  call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %10, ptr align 4 readonly nonnull %11)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %9, ptr align 4 %10, i64 4, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 4 %9, i64 4, i1 false)
  %60 = getelementptr inbounds %io.Writer, ptr %7, i32 0, i32 0
  store ptr %8, ptr %6, align 8
  %61 = load ptr, ptr %6, align 8
  %62 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %61, i32 0, i32 0
  store ptr %62, ptr %60, align 8
  %63 = getelementptr inbounds %io.Writer, ptr %7, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %63, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %5, ptr align 8 %7, i64 16, i1 false)
  %64 = call fastcc i16 @io.Writer.print__anon_4006(ptr align 8 readonly nonnull %5)
  %65 = icmp eq i16 %64, 0
  br i1 %65, label %67, label %68

66:
  br label %30

67:
  br label %66

68:
  call fastcc void @posix.abort()
  unreachable
}

; Function Attrs: nounwind uwtable
define internal fastcc i64 @Thread.getCurrentId() unnamed_addr #0 {
0:
  %1 = call fastcc i64 @Thread.PosixThreadImpl.getCurrentId()
  ret i64 %1
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.lock(ptr align 4 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  store ptr %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  %4 = getelementptr inbounds %Thread.Mutex, ptr %3, i32 0, i32 0
  call fastcc void @Thread.Mutex.DarwinImpl.lock(ptr align 4 nonnull %4)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.assert(i1 %0) unnamed_addr #0 {
1:
  %2 = xor i1 %0, true
  br i1 %2, label %4, label %5

3:
  ret void

4:
  unreachable

5:
  br label %3
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @Progress.write(ptr align 1 readonly nonnull %0, i64 %1) unnamed_addr #0 {
2:
  %3 = insertvalue { ptr, i64 } poison, ptr %0, 0
  %4 = insertvalue { ptr, i64 } %3, i64 %1, 1
  %5 = extractvalue { ptr, i64 } %4, 0
  %6 = extractvalue { ptr, i64 } %4, 1
  %7 = call fastcc i16 @fs.File.writeAll(ptr align 4 readonly nonnull getelementptr inbounds (i8, ptr @Progress.global_progress, i64 96), ptr align 1 readonly nonnull %5, i64 %6)
  %8 = icmp ne i16 %7, 0
  br i1 %8, label %9, label %10

9:
  ret i16 %7

10:
  ret i16 0
}

; Function Attrs: nounwind speculatable willreturn nofree nosync nocallback memory(none)
declare i64 @llvm.umin.i64(i64 %0, i64 %1) #5

; Function Attrs: nounwind uwtable
declare i64 @write(i32 %0, ptr align 1 readonly nonnull %1, i64 %2) #0

; Function Attrs: nounwind uwtable
define internal fastcc i16 @posix.errno__anon_3734(i64 %0) unnamed_addr #0 {
1:
  %2 = icmp eq i64 %0, -1
  br i1 %2, label %5, label %9

3:
  %4 = phi i16 [ %8, %5 ], [ 0, %9 ]
  ret i16 %4

5:
  %6 = call ptr @__error()
  %7 = load i32, ptr %6, align 4
  %8 = trunc i32 %7 to i16
  br label %3

9:
  br label %3
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @posix.unexpectedErrno(i16 %0) unnamed_addr #0 {
1:
  ret i16 16
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatValue__anon_3979(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = call fastcc i16 @fmt.formatIntValue__anon_4007(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1)
  ret i16 %3
}

; Function Attrs: nounwind uwtable
define internal fastcc void @io.Writer.write(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 8 readonly nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %8 = insertvalue { ptr, i64 } %7, i64 %3, 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %6, ptr align 8 %1, i64 16, i1 false)
  %9 = getelementptr inbounds %io.Writer, ptr %6, i32 0, i32 1
  %10 = load ptr, ptr %9, align 8
  %11 = getelementptr inbounds %io.Writer, ptr %1, i32 0, i32 0
  %12 = load ptr, ptr %11, align 8
  %13 = extractvalue { ptr, i64 } %8, 0
  %14 = extractvalue { ptr, i64 } %8, 1
  call fastcc void %10(ptr sret({ i64, i16, [6 x i8] }) %5, ptr align 1 readonly nonnull %12, ptr align 1 readonly nonnull %13, i64 %14)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 %5, i64 16, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.unlock(ptr align 4 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  store ptr %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  %4 = getelementptr inbounds %Thread.Mutex, ptr %3, i32 0, i32 0
  call fastcc void @Thread.Mutex.DarwinImpl.unlock(ptr align 4 nonnull %4)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @"io.fixed_buffer_stream.FixedBufferStream([]u8).write"(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 8 nonnull %1, ptr align 1 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [8 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = alloca [8 x i8], align 8
  %8 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %9 = insertvalue { ptr, i64 } %8, i64 %3, 1
  %10 = extractvalue { ptr, i64 } %9, 1
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %19, label %20

12:
  %13 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %1, i32 0, i32 1
  %14 = load i64, ptr %13, align 8
  %15 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %1, i32 0, i32 0
  %16 = load { ptr, i64 }, ptr %15, align 8
  %17 = extractvalue { ptr, i64 } %16, 1
  %18 = icmp uge i64 %14, %17
  br i1 %18, label %52, label %53

19:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @22, i64 16, i1 false)
  ret void

20:
  br label %12

21:
  %22 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %1, i32 0, i32 0
  %23 = load { ptr, i64 }, ptr %22, align 8
  %24 = extractvalue { ptr, i64 } %23, 1
  %25 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %1, i32 0, i32 1
  %26 = load i64, ptr %25, align 8
  %27 = sub nuw i64 %24, %26
  %28 = extractvalue { ptr, i64 } %9, 1
  %29 = call i64 @llvm.umin.i64(i64 %27, i64 %28)
  store ptr %1, ptr %7, align 8
  %30 = load ptr, ptr %7, align 8
  %31 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %30, i32 0, i32 0
  %32 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %1, i32 0, i32 1
  %33 = load i64, ptr %32, align 8
  %34 = load { ptr, i64 }, ptr %31, align 8
  %35 = extractvalue { ptr, i64 } %34, 0
  %36 = getelementptr inbounds i8, ptr %35, i64 %33
  %37 = insertvalue { ptr, i64 } poison, ptr %36, 0
  %38 = insertvalue { ptr, i64 } %37, i64 %29, 1
  store { ptr, i64 } %9, ptr %6, align 8
  %39 = load { ptr, i64 }, ptr %6, align 8
  %40 = extractvalue { ptr, i64 } %39, 0
  %41 = getelementptr inbounds i8, ptr %40, i64 0
  %42 = insertvalue { ptr, i64 } poison, ptr %41, 0
  %43 = insertvalue { ptr, i64 } %42, i64 %29, 1
  %44 = extractvalue { ptr, i64 } %43, 0
  %45 = extractvalue { ptr, i64 } %38, 1
  %46 = extractvalue { ptr, i64 } %38, 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %46, ptr align 1 %44, i64 %45, i1 false)
  store ptr %1, ptr %5, align 8
  %47 = load ptr, ptr %5, align 8
  %48 = getelementptr inbounds %"io.fixed_buffer_stream.FixedBufferStream([]u8)", ptr %47, i32 0, i32 1
  %49 = load i64, ptr %48, align 8
  %50 = add nuw i64 %49, %29
  store i64 %50, ptr %48, align 8
  %51 = icmp eq i64 %29, 0
  br i1 %51, label %57, label %58

52:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @23, i64 16, i1 false)
  ret void

53:
  br label %21

54:
  %55 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %55, align 2
  %56 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  store i64 %29, ptr %56, align 8
  ret void

57:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @23, i64 16, i1 false)
  ret void

58:
  br label %54
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatBuf__anon_3980(ptr align 1 readonly nonnull %0, i64 %1, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = alloca [16 x i8], align 8
  %8 = alloca [16 x i8], align 8
  %9 = alloca [16 x i8], align 8
  %10 = alloca [16 x i8], align 8
  %11 = alloca [16 x i8], align 8
  %12 = alloca [16 x i8], align 8
  %13 = alloca [16 x i8], align 8
  %14 = alloca [4 x i8], align 2
  %15 = alloca [4 x i8], align 1
  %16 = alloca [16 x i8], align 8
  %17 = alloca [16 x i8], align 8
  %18 = alloca [16 x i8], align 8
  %19 = insertvalue { ptr, i64 } poison, ptr %0, 0
  %20 = insertvalue { ptr, i64 } %19, i64 %1, 1
  %21 = getelementptr inbounds %fmt.FormatOptions, ptr %2, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %18, ptr align 8 %21, i64 16, i1 false)
  %22 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %18, i32 0, i32 1
  %23 = load i8, ptr %22
  %24 = icmp ne i8 %23, 0
  br i1 %24, label %26, label %34

25:
  ret i16 0

26:
  %27 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %18, i32 0, i32 0
  %28 = load i64, ptr %27, align 8
  %29 = extractvalue { ptr, i64 } %20, 0
  %30 = extractvalue { ptr, i64 } %20, 1
  call fastcc void @unicode.utf8CountCodepoints(ptr sret({ i64, i16, [6 x i8] }) %17, ptr align 1 readonly nonnull %29, i64 %30)
  %31 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %17, i32 0, i32 1
  %32 = load i16, ptr %31
  %33 = icmp eq i16 %32, 0
  br i1 %33, label %42, label %45

34:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %5, ptr align 8 %3, i64 16, i1 false)
  %35 = extractvalue { ptr, i64 } %20, 0
  %36 = extractvalue { ptr, i64 } %20, 1
  %37 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %5, ptr align 1 readonly nonnull %35, i64 %36)
  %38 = icmp ne i16 %37, 0
  br i1 %38, label %138, label %139

39:
  %40 = phi i64 [ %44, %42 ], [ %46, %45 ]
  %41 = icmp ult i64 %40, %28
  br i1 %41, label %50, label %52

42:
  %43 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %17, i32 0, i32 0
  %44 = load i64, ptr %43, align 8
  br label %39

45:
  %46 = extractvalue { ptr, i64 } %20, 1
  br label %39

47:
  %48 = phi i64 [ %51, %50 ], [ 0, %52 ]
  %49 = icmp eq i64 %48, 0
  br i1 %49, label %65, label %69

50:
  %51 = sub nuw i64 %28, %40
  br label %47

52:
  br label %47

53:
  call void @llvm.memset.p0.i64(ptr align 1 %15, i8 undef, i64 4, i1 false)
  %54 = getelementptr inbounds %fmt.FormatOptions, ptr %2, i32 0, i32 2
  %55 = load i32, ptr %54, align 4
  %56 = trunc i32 %55 to i21
  %57 = getelementptr inbounds [4 x i8], ptr %15, i64 0, i64 0
  %58 = insertvalue { ptr, i64 } poison, ptr %57, 0
  %59 = insertvalue { ptr, i64 } %58, i64 4, 1
  %60 = extractvalue { ptr, i64 } %59, 0
  %61 = extractvalue { ptr, i64 } %59, 1
  call fastcc void @unicode.utf8Encode(ptr sret({ i16, i3, [1 x i8] }) %14, i21 %56, ptr align 1 nonnull %60, i64 %61)
  %62 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %14, i32 0, i32 0
  %63 = load i16, ptr %62
  %64 = icmp eq i16 %63, 0
  br i1 %64, label %75, label %83

65:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %16, ptr align 8 %3, i64 16, i1 false)
  %66 = extractvalue { ptr, i64 } %20, 0
  %67 = extractvalue { ptr, i64 } %20, 1
  %68 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %16, ptr align 1 readonly nonnull %66, i64 %67)
  ret i16 %68

69:
  br label %53

70:
  %71 = phi { ptr, i64 } [ %82, %75 ], [ { ptr getelementptr inbounds (i8, ptr @__anon_3651, i64 0), i64 3 }, %87 ]
  %72 = getelementptr inbounds %fmt.FormatOptions, ptr %2, i32 0, i32 3
  %73 = load i8, ptr %72, align 1
  %74 = trunc i8 %73 to i2
  switch i2 %74, label %89 [
    i2 0, label %90
    i2 1, label %103
    i2 -2, label %125
  ]

75:
  %76 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %14, i32 0, i32 1
  %77 = load i3, ptr %76, align 1
  %78 = getelementptr inbounds i8, ptr %15, i64 0
  %79 = zext i3 %77 to i64
  %80 = insertvalue { ptr, i64 } poison, ptr %78, 0
  %81 = insertvalue { ptr, i64 } %80, i64 %79, 1
  store { ptr, i64 } %81, ptr %13, align 8
  %82 = load { ptr, i64 }, ptr %13, align 8
  br label %70

83:
  %84 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %14, i32 0, i32 0
  %85 = load i16, ptr %84
  switch i16 %85, label %86 [
    i16 25, label %87
    i16 26, label %87
  ]

86:
  unreachable

87:
  br label %70

88:
  br label %25

89:
  unreachable

90:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %12, ptr align 8 %3, i64 16, i1 false)
  %91 = extractvalue { ptr, i64 } %20, 0
  %92 = extractvalue { ptr, i64 } %20, 1
  %93 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %12, ptr align 1 readonly nonnull %91, i64 %92)
  %94 = icmp ne i16 %93, 0
  br i1 %94, label %95, label %96

95:
  ret i16 %93

96:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %11, ptr align 8 %3, i64 16, i1 false)
  %97 = extractvalue { ptr, i64 } %71, 0
  %98 = extractvalue { ptr, i64 } %71, 1
  %99 = call fastcc i16 @io.Writer.writeBytesNTimes(ptr align 8 readonly nonnull %11, ptr align 1 readonly nonnull %97, i64 %98, i64 %48)
  %100 = icmp ne i16 %99, 0
  br i1 %100, label %101, label %102

101:
  ret i16 %99

102:
  br label %88

103:
  %104 = udiv i64 %48, 2
  %105 = add nuw i64 %48, 1
  %106 = udiv i64 %105, 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %10, ptr align 8 %3, i64 16, i1 false)
  %107 = extractvalue { ptr, i64 } %71, 0
  %108 = extractvalue { ptr, i64 } %71, 1
  %109 = call fastcc i16 @io.Writer.writeBytesNTimes(ptr align 8 readonly nonnull %10, ptr align 1 readonly nonnull %107, i64 %108, i64 %104)
  %110 = icmp ne i16 %109, 0
  br i1 %110, label %111, label %112

111:
  ret i16 %109

112:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %9, ptr align 8 %3, i64 16, i1 false)
  %113 = extractvalue { ptr, i64 } %20, 0
  %114 = extractvalue { ptr, i64 } %20, 1
  %115 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %9, ptr align 1 readonly nonnull %113, i64 %114)
  %116 = icmp ne i16 %115, 0
  br i1 %116, label %117, label %118

117:
  ret i16 %115

118:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %8, ptr align 8 %3, i64 16, i1 false)
  %119 = extractvalue { ptr, i64 } %71, 0
  %120 = extractvalue { ptr, i64 } %71, 1
  %121 = call fastcc i16 @io.Writer.writeBytesNTimes(ptr align 8 readonly nonnull %8, ptr align 1 readonly nonnull %119, i64 %120, i64 %106)
  %122 = icmp ne i16 %121, 0
  br i1 %122, label %123, label %124

123:
  ret i16 %121

124:
  br label %88

125:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %7, ptr align 8 %3, i64 16, i1 false)
  %126 = extractvalue { ptr, i64 } %71, 0
  %127 = extractvalue { ptr, i64 } %71, 1
  %128 = call fastcc i16 @io.Writer.writeBytesNTimes(ptr align 8 readonly nonnull %7, ptr align 1 readonly nonnull %126, i64 %127, i64 %48)
  %129 = icmp ne i16 %128, 0
  br i1 %129, label %130, label %131

130:
  ret i16 %128

131:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %6, ptr align 8 %3, i64 16, i1 false)
  %132 = extractvalue { ptr, i64 } %20, 0
  %133 = extractvalue { ptr, i64 } %20, 1
  %134 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %6, ptr align 1 readonly nonnull %132, i64 %133)
  %135 = icmp ne i16 %134, 0
  br i1 %135, label %136, label %137

136:
  ret i16 %134

137:
  br label %88

138:
  ret i16 %37

139:
  br label %25
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.print__anon_4004(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = call fastcc i16 @fmt.format__anon_4018(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1)
  ret i16 %3
}

; Function Attrs: noreturn nounwind uwtable cold
define internal fastcc void @posix.abort() unnamed_addr #1 {
0:
  call void @abort()
  unreachable
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.print__anon_4005(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = call fastcc i16 @fmt.format__anon_4019(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1)
  ret i16 %3
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.dumpStackTrace(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [16 x i8], align 8
  %3 = alloca [8 x i8], align 8
  %4 = alloca [16 x i8], align 8
  %5 = alloca [4 x i8], align 4
  %6 = alloca [4 x i8], align 4
  %7 = alloca [4 x i8], align 4
  %8 = alloca [4 x i8], align 4
  %9 = alloca [4 x i8], align 4
  call fastcc void @io.getStdErr(ptr sret(%fs.File) %9)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 4 %9, i64 4, i1 false)
  call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %7, ptr align 4 readonly nonnull %8)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 4, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %6, i64 4, i1 false)
  %10 = getelementptr inbounds %io.Writer, ptr %4, i32 0, i32 0
  store ptr %5, ptr %3, align 8
  %11 = load ptr, ptr %3, align 8
  %12 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %11, i32 0, i32 0
  store ptr %12, ptr %10, align 8
  %13 = getelementptr inbounds %io.Writer, ptr %4, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %13, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %4, i64 16, i1 false)
  %14 = call fastcc i16 @io.Writer.print__anon_4020(ptr align 8 readonly nonnull %2)
  %15 = icmp eq i16 %14, 0
  br i1 %15, label %17, label %18

16:
  ret void

17:
  br label %16

18:
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.dumpCurrentStackTrace(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [16 x i8], align 8
  %3 = alloca [8 x i8], align 8
  %4 = alloca [16 x i8], align 8
  %5 = alloca [4 x i8], align 4
  %6 = alloca [4 x i8], align 4
  %7 = alloca [4 x i8], align 4
  %8 = alloca [4 x i8], align 4
  %9 = alloca [4 x i8], align 4
  call fastcc void @io.getStdErr(ptr sret(%fs.File) %9)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 4 %9, i64 4, i1 false)
  call fastcc void @fs.File.writer(ptr sret(%"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))") %7, ptr align 4 readonly nonnull %8)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 4, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %6, i64 4, i1 false)
  %10 = getelementptr inbounds %io.Writer, ptr %4, i32 0, i32 0
  store ptr %5, ptr %3, align 8
  %11 = load ptr, ptr %3, align 8
  %12 = getelementptr inbounds %"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write'))", ptr %11, i32 0, i32 0
  store ptr %12, ptr %10, align 8
  %13 = getelementptr inbounds %io.Writer, ptr %4, i32 0, i32 1
  store ptr getelementptr inbounds (i8, ptr @"io.GenericWriter(fs.File,error{DiskQuota,FileTooBig,InputOutput,NoSpaceLeft,DeviceBusy,InvalidArgument,AccessDenied,BrokenPipe,SystemResources,OperationAborted,NotOpenForWriting,LockViolation,WouldBlock,ConnectionResetByPeer,Unexpected},(function 'write')).typeErasedWriteFn", i64 0), ptr %13, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %4, i64 16, i1 false)
  %14 = call fastcc i16 @io.Writer.print__anon_4020(ptr align 8 readonly nonnull %2)
  %15 = icmp eq i16 %14, 0
  br i1 %15, label %17, label %18

16:
  ret void

17:
  br label %16

18:
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc void @debug.waitForOtherThreadToFinishPanicking() unnamed_addr #0 {
0:
  %1 = alloca [4 x i8], align 4
  %2 = alloca [4 x i8], align 4
  %3 = atomicrmw sub ptr getelementptr inbounds (i8, ptr @debug.panicking, i64 0), i8 1 seq_cst, align 1
  %4 = icmp ne i8 %3, 1
  br i1 %4, label %6, label %7

5:
  ret void

6:
  call fastcc void @"atomic.Value(u32).init"(ptr sret(%"atomic.Value(u32)") %1, i32 0)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %2, ptr align 4 %1, i64 4, i1 false)
  br label %8

7:
  br label %5

8:
  call fastcc void @Thread.Futex.wait(ptr align 4 readonly nonnull %2, i32 0)
  br label %8
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.print__anon_4006(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = call fastcc i16 @fmt.format__anon_4050(ptr align 8 readonly nonnull %0)
  ret i16 %2
}

; Function Attrs: nounwind uwtable
define internal fastcc i64 @Thread.PosixThreadImpl.getCurrentId() unnamed_addr #0 {
0:
  %1 = alloca [8 x i8], align 8
  call void @llvm.memset.p0.i64(ptr align 8 %1, i8 undef, i64 8, i1 false)
  %2 = call i32 @pthread_threadid_np(ptr align 1 null, ptr align 8 nonnull %1)
  %3 = icmp eq i32 %2, 0
  call fastcc void @debug.assert(i1 %3)
  %4 = load i64, ptr %1, align 8
  ret i64 %4
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.DarwinImpl.lock(ptr align 4 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  store ptr %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  %4 = getelementptr inbounds %Thread.Mutex.DarwinImpl, ptr %3, i32 0, i32 0
  call void @os_unfair_lock_lock(ptr align 4 nonnull %4)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fs.File.writeAll(ptr align 4 readonly nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [16 x i8], align 8
  %5 = alloca [16 x i8], align 8
  %6 = alloca [4 x i8], align 4
  %7 = alloca [4 x i8], align 4
  %8 = alloca [8 x i8], align 8
  %9 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %10 = insertvalue { ptr, i64 } %9, i64 %2, 1
  store i64 0, ptr %8, align 8
  br label %12

11:
  ret i16 0

12:
  %13 = load i64, ptr %8, align 8
  %14 = extractvalue { ptr, i64 } %10, 1
  %15 = icmp ult i64 %13, %14
  br i1 %15, label %17, label %32

16:
  br label %12

17:
  %18 = load i64, ptr %8, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %0, i64 4, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 4, i1 false)
  store { ptr, i64 } %10, ptr %5, align 8
  %19 = load i64, ptr %8, align 8
  %20 = load { ptr, i64 }, ptr %5, align 8
  %21 = extractvalue { ptr, i64 } %20, 0
  %22 = getelementptr inbounds i8, ptr %21, i64 %19
  %23 = extractvalue { ptr, i64 } %20, 1
  %24 = sub nuw i64 %23, %19
  %25 = insertvalue { ptr, i64 } poison, ptr %22, 0
  %26 = insertvalue { ptr, i64 } %25, i64 %24, 1
  %27 = extractvalue { ptr, i64 } %26, 0
  %28 = extractvalue { ptr, i64 } %26, 1
  call fastcc void @fs.File.write(ptr sret({ i64, i16, [6 x i8] }) %4, ptr align 4 readonly nonnull %6, ptr align 1 readonly nonnull %27, i64 %28)
  %29 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 1
  %30 = load i16, ptr %29
  %31 = icmp ne i16 %30, 0
  br i1 %31, label %33, label %36

32:
  br label %11

33:
  %34 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 1
  %35 = load i16, ptr %34
  ret i16 %35

36:
  %37 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %4, i32 0, i32 0
  %38 = load i64, ptr %37, align 8
  %39 = add nuw i64 %18, %38
  store i64 %39, ptr %8, align 8
  br label %16
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8ByteSequenceLength(ptr noalias sret({ i16, i3, [1 x i8] }) nonnull %0, i8 %1) unnamed_addr #0 {
2:
  switch i8 %1, label %5 [
  ]

3:
  %4 = phi ptr [ @16, %9 ], [ @17, %14 ], [ @18, %19 ], [ @19, %24 ], [ @20, %25 ]
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 %4, i64 4, i1 false)
  ret void

5:
  %6 = icmp uge i8 %1, 0
  %7 = icmp ule i8 %1, 127
  %8 = and i1 %6, %7
  br i1 %8, label %9, label %10

9:
  br label %3

10:
  %11 = icmp uge i8 %1, -64
  %12 = icmp ule i8 %1, -33
  %13 = and i1 %11, %12
  br i1 %13, label %14, label %15

14:
  br label %3

15:
  %16 = icmp uge i8 %1, -32
  %17 = icmp ule i8 %1, -17
  %18 = and i1 %16, %17
  br i1 %18, label %19, label %20

19:
  br label %3

20:
  %21 = icmp uge i8 %1, -16
  %22 = icmp ule i8 %1, -9
  %23 = and i1 %21, %22
  br i1 %23, label %24, label %25

24:
  br label %3

25:
  br label %3
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8CountCodepoints(ptr noalias sret({ i64, i16, [6 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [8 x i8], align 4
  %5 = alloca [16 x i8], align 8
  %6 = alloca [4 x i8], align 2
  %7 = alloca [16 x i8], align 8
  %8 = alloca [8 x i8], align 8
  %9 = alloca [8 x i8], align 8
  %10 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %11 = insertvalue { ptr, i64 } %10, i64 %2, 1
  store i64 0, ptr %9, align 8
  store i64 0, ptr %8, align 8
  br label %16

12:
  %13 = load i64, ptr %9, align 8
  %14 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %14, align 2
  %15 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  store i64 %13, ptr %15, align 8
  ret void

16:
  %17 = load i64, ptr %8, align 8
  %18 = extractvalue { ptr, i64 } %11, 1
  %19 = icmp ult i64 %17, %18
  br i1 %19, label %21, label %22

20:
  br label %16

21:
  br label %27

22:
  br label %12

23:
  %24 = load i64, ptr %8, align 8
  %25 = extractvalue { ptr, i64 } %11, 1
  %26 = icmp ult i64 %24, %25
  br i1 %26, label %50, label %58

27:
  %28 = load i64, ptr %8, align 8
  %29 = add nuw i64 %28, 8
  %30 = extractvalue { ptr, i64 } %11, 1
  %31 = icmp ule i64 %29, %30
  br i1 %31, label %33, label %41

32:
  br label %27

33:
  store { ptr, i64 } %11, ptr %7, align 8
  %34 = load i64, ptr %8, align 8
  %35 = load { ptr, i64 }, ptr %7, align 8
  %36 = extractvalue { ptr, i64 } %35, 0
  %37 = getelementptr inbounds i8, ptr %36, i64 %34
  %38 = load i64, ptr %37, align 1
  %39 = and i64 %38, -9187201950435737472
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %47, label %48

41:
  br label %23

42:
  %43 = load i64, ptr %9, align 8
  %44 = add nuw i64 %43, 8
  store i64 %44, ptr %9, align 8
  %45 = load i64, ptr %8, align 8
  %46 = add nuw i64 %45, 8
  store i64 %46, ptr %8, align 8
  br label %32

47:
  br label %23

48:
  br label %42

49:
  br label %20

50:
  %51 = load i64, ptr %8, align 8
  %52 = extractvalue { ptr, i64 } %11, 0
  %53 = getelementptr inbounds i8, ptr %52, i64 %51
  %54 = load i8, ptr %53, align 1
  call fastcc void @unicode.utf8ByteSequenceLength(ptr sret({ i16, i3, [1 x i8] }) %6, i8 %54)
  %55 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %6, i32 0, i32 0
  %56 = load i16, ptr %55
  %57 = icmp ne i16 %56, 0
  br i1 %57, label %59, label %64

58:
  br label %49

59:
  %60 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %6, i32 0, i32 0
  %61 = load i16, ptr %60
  %62 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 %61, ptr %62, align 2
  %63 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  ret void

64:
  %65 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %6, i32 0, i32 1
  %66 = load i3, ptr %65, align 1
  %67 = load i64, ptr %8, align 8
  %68 = zext i3 %66 to i64
  %69 = add nuw i64 %67, %68
  %70 = extractvalue { ptr, i64 } %11, 1
  %71 = icmp ugt i64 %69, %70
  br i1 %71, label %73, label %74

72:
  switch i3 %66, label %81 [
    i3 1, label %94
  ]

73:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %0, ptr align 8 @21, i64 16, i1 false)
  ret void

74:
  br label %72

75:
  %76 = load i64, ptr %8, align 8
  %77 = zext i3 %66 to i64
  %78 = add nuw i64 %76, %77
  store i64 %78, ptr %8, align 8
  %79 = load i64, ptr %9, align 8
  %80 = add nuw i64 %79, 1
  store i64 %80, ptr %9, align 8
  br label %49

81:
  store { ptr, i64 } %11, ptr %5, align 8
  %82 = load i64, ptr %8, align 8
  %83 = load { ptr, i64 }, ptr %5, align 8
  %84 = extractvalue { ptr, i64 } %83, 0
  %85 = getelementptr inbounds i8, ptr %84, i64 %82
  %86 = zext i3 %66 to i64
  %87 = insertvalue { ptr, i64 } poison, ptr %85, 0
  %88 = insertvalue { ptr, i64 } %87, i64 %86, 1
  %89 = extractvalue { ptr, i64 } %88, 0
  %90 = extractvalue { ptr, i64 } %88, 1
  call fastcc void @unicode.utf8Decode(ptr sret({ i21, i16, [2 x i8] }) %4, ptr align 1 readonly nonnull %89, i64 %90)
  %91 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %4, i32 0, i32 1
  %92 = load i16, ptr %91
  %93 = icmp ne i16 %92, 0
  br i1 %93, label %95, label %100

94:
  br label %75

95:
  %96 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %4, i32 0, i32 1
  %97 = load i16, ptr %96
  %98 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 1
  store i16 %97, ptr %98, align 2
  %99 = getelementptr inbounds { i64, i16, [6 x i8] }, ptr %0, i32 0, i32 0
  ret void

100:
  br label %75
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Decode(ptr noalias sret({ i21, i16, [2 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [8 x i8], align 4
  %5 = alloca [8 x i8], align 4
  %6 = alloca [8 x i8], align 4
  %7 = alloca [8 x i8], align 4
  %8 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %9 = insertvalue { ptr, i64 } %8, i64 %2, 1
  %10 = extractvalue { ptr, i64 } %9, 1
  switch i64 %10, label %13 [
    i64 1, label %14
    i64 2, label %21
    i64 3, label %24
    i64 4, label %27
  ]

11:
  %12 = phi ptr [ %7, %14 ], [ %6, %21 ], [ %5, %24 ], [ %4, %27 ]
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %12, i64 8, i1 false)
  ret void

13:
  unreachable

14:
  %15 = extractvalue { ptr, i64 } %9, 0
  %16 = getelementptr inbounds i8, ptr %15, i64 0
  %17 = load i8, ptr %16, align 1
  %18 = zext i8 %17 to i21
  %19 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %7, i32 0, i32 1
  store i16 0, ptr %19, align 2
  %20 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %7, i32 0, i32 0
  store i21 %18, ptr %20, align 4
  br label %11

21:
  %22 = extractvalue { ptr, i64 } %9, 0
  %23 = extractvalue { ptr, i64 } %9, 1
  call fastcc void @unicode.utf8Decode2(ptr sret({ i21, i16, [2 x i8] }) %6, ptr align 1 readonly nonnull %22, i64 %23)
  br label %11

24:
  %25 = extractvalue { ptr, i64 } %9, 0
  %26 = extractvalue { ptr, i64 } %9, 1
  call fastcc void @unicode.utf8Decode3(ptr sret({ i21, i16, [2 x i8] }) %5, ptr align 1 readonly nonnull %25, i64 %26)
  br label %11

27:
  %28 = extractvalue { ptr, i64 } %9, 0
  %29 = extractvalue { ptr, i64 } %9, 1
  call fastcc void @unicode.utf8Decode4(ptr sret({ i21, i16, [2 x i8] }) %4, ptr align 1 readonly nonnull %28, i64 %29)
  br label %11
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Encode(ptr noalias sret({ i16, i3, [1 x i8] }) nonnull %0, i21 %1, ptr align 1 nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [4 x i8], align 2
  %6 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %7 = insertvalue { ptr, i64 } %6, i64 %3, 1
  %8 = extractvalue { ptr, i64 } %7, 0
  %9 = extractvalue { ptr, i64 } %7, 1
  call fastcc void @unicode.utf8EncodeImpl__anon_4051(ptr sret({ i16, i3, [1 x i8] }) %5, i21 %1, ptr align 1 nonnull %8, i64 %9)
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 %5, i64 4, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.writeBytesNTimes(ptr align 8 readonly nonnull %0, ptr align 1 readonly nonnull %1, i64 %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = alloca [8 x i8], align 8
  %7 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %8 = insertvalue { ptr, i64 } %7, i64 %2, 1
  store i64 0, ptr %6, align 8
  br label %10

9:
  ret i16 0

10:
  %11 = load i64, ptr %6, align 8
  %12 = icmp ult i64 %11, %3
  br i1 %12, label %14, label %19

13:
  br label %10

14:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %5, ptr align 8 %0, i64 16, i1 false)
  %15 = extractvalue { ptr, i64 } %8, 0
  %16 = extractvalue { ptr, i64 } %8, 1
  %17 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %5, ptr align 1 readonly nonnull %15, i64 %16)
  %18 = icmp ne i16 %17, 0
  br i1 %18, label %20, label %21

19:
  br label %9

20:
  ret i16 %17

21:
  %22 = load i64, ptr %6, align 8
  %23 = add nuw i64 %22, 1
  store i64 %23, ptr %6, align 8
  br label %13
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatInt__anon_4016(i11 %0, i8 %1, i1 %2, ptr align 8 readonly nonnull %3, ptr align 8 readonly nonnull %4) unnamed_addr #0 {
5:
  %6 = alloca [16 x i8], align 8
  %7 = alloca [2 x i8], align 1
  %8 = alloca [2 x i8], align 1
  %9 = alloca [8 x i8], align 8
  %10 = alloca [2 x i8], align 2
  %11 = alloca [12 x i8], align 1
  %12 = icmp uge i8 %1, 2
  call fastcc void @debug.assert(i1 %12)
  call void @llvm.memset.p0.i64(ptr align 1 %11, i8 undef, i64 12, i1 false)
  store i11 %0, ptr %10, align 2
  store i64 12, ptr %9, align 8
  %13 = icmp eq i8 %1, 10
  br i1 %13, label %24, label %25

14:
  %15 = load i64, ptr %9, align 8
  %16 = getelementptr inbounds i8, ptr %11, i64 %15
  %17 = sub nuw i64 12, %15
  %18 = insertvalue { ptr, i64 } poison, ptr %16, 0
  %19 = insertvalue { ptr, i64 } %18, i64 %17, 1
  store { ptr, i64 } %19, ptr %6, align 8
  %20 = load { ptr, i64 }, ptr %6, align 8
  %21 = extractvalue { ptr, i64 } %20, 0
  %22 = extractvalue { ptr, i64 } %20, 1
  %23 = call fastcc i16 @fmt.formatBuf__anon_3980(ptr align 1 readonly nonnull %21, i64 %22, ptr align 8 readonly nonnull %3, ptr align 8 readonly nonnull %4)
  ret i16 %23

24:
  br label %30

25:
  br label %67

26:
  %27 = load i16, ptr %10, align 2
  %28 = trunc i16 %27 to i11
  %29 = icmp ult i11 %28, 10
  br i1 %29, label %49, label %58

30:
  %31 = load i16, ptr %10, align 2
  %32 = trunc i16 %31 to i11
  %33 = icmp uge i11 %32, 100
  br i1 %33, label %35, label %47

34:
  br label %30

35:
  %36 = load i64, ptr %9, align 8
  %37 = sub nuw i64 %36, 2
  store i64 %37, ptr %9, align 8
  %38 = load i64, ptr %9, align 8
  %39 = getelementptr inbounds i8, ptr %11, i64 %38
  %40 = load i16, ptr %10, align 2
  %41 = trunc i16 %40 to i11
  %42 = urem i11 %41, 100
  %43 = zext i11 %42 to i64
  call fastcc void @fmt.digits2(ptr sret([2 x i8]) %8, i64 %43)
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %39, ptr align 1 %8, i64 2, i1 false)
  %44 = load i16, ptr %10, align 2
  %45 = trunc i16 %44 to i11
  %46 = udiv i11 %45, 100
  store i11 %46, ptr %10, align 2
  br label %34

47:
  br label %26

48:
  br label %14

49:
  %50 = load i64, ptr %9, align 8
  %51 = sub nuw i64 %50, 1
  store i64 %51, ptr %9, align 8
  %52 = load i64, ptr %9, align 8
  %53 = getelementptr inbounds [12 x i8], ptr %11, i64 0, i64 %52
  %54 = load i16, ptr %10, align 2
  %55 = trunc i16 %54 to i11
  %56 = trunc i11 %55 to i8
  %57 = add nuw i8 48, %56
  store i8 %57, ptr %53, align 1
  br label %48

58:
  %59 = load i64, ptr %9, align 8
  %60 = sub nuw i64 %59, 2
  store i64 %60, ptr %9, align 8
  %61 = load i64, ptr %9, align 8
  %62 = getelementptr inbounds i8, ptr %11, i64 %61
  %63 = load i16, ptr %10, align 2
  %64 = trunc i16 %63 to i11
  %65 = zext i11 %64 to i64
  call fastcc void @fmt.digits2(ptr sret([2 x i8]) %7, i64 %65)
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %62, ptr align 1 %7, i64 2, i1 false)
  br label %48

66:
  br label %14

67:
  %68 = load i16, ptr %10, align 2
  %69 = trunc i16 %68 to i11
  %70 = zext i8 %1 to i11
  %71 = urem i11 %69, %70
  %72 = load i64, ptr %9, align 8
  %73 = sub nuw i64 %72, 1
  store i64 %73, ptr %9, align 8
  %74 = load i64, ptr %9, align 8
  %75 = getelementptr inbounds [12 x i8], ptr %11, i64 0, i64 %74
  %76 = trunc i11 %71 to i8
  %77 = call fastcc i8 @fmt.digitToChar(i8 %76, i1 %2)
  store i8 %77, ptr %75, align 1
  %78 = load i16, ptr %10, align 2
  %79 = trunc i16 %78 to i11
  %80 = zext i8 %1 to i11
  %81 = udiv i11 %79, %80
  store i11 %81, ptr %10, align 2
  %82 = load i16, ptr %10, align 2
  %83 = trunc i16 %82 to i11
  %84 = icmp eq i11 %83, 0
  br i1 %84, label %86, label %87

85:
  br label %67

86:
  br label %66

87:
  br label %85
}

; Function Attrs: nounwind uwtable
define internal fastcc void @fmt.digits2(ptr noalias sret([2 x i8]) nonnull %0, i64 %1) unnamed_addr #0 {
2:
  %3 = mul nuw i64 %1, 2
  %4 = getelementptr inbounds i8, ptr getelementptr inbounds (i8, ptr @__anon_3758, i64 0), i64 %3
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %0, ptr align 1 %4, i64 2, i1 false)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i8 @fmt.digitToChar(i8 %0, i1 %1) unnamed_addr #0 {
2:
  switch i8 %0, label %5 [
  ]

3:
  %4 = phi i8 [ %10, %9 ], [ %21, %18 ]
  ret i8 %4

5:
  %6 = icmp uge i8 %0, 0
  %7 = icmp ule i8 %0, 9
  %8 = and i1 %6, %7
  br i1 %8, label %9, label %11

9:
  %10 = add nuw i8 %0, 48
  br label %3

11:
  %12 = icmp uge i8 %0, 10
  %13 = icmp ule i8 %0, 35
  %14 = and i1 %12, %13
  br i1 %14, label %15, label %17

15:
  %16 = icmp eq i1 %1, true
  br i1 %16, label %22, label %23

17:
  unreachable

18:
  %19 = phi i8 [ 65, %22 ], [ 97, %23 ]
  %20 = sub nuw i8 %19, 10
  %21 = add nuw i8 %0, %20
  br label %3

22:
  br label %18

23:
  br label %18
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatIntValue__anon_4007(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = call fastcc i16 @fmt.formatInt__anon_4016(i11 -535, i8 10, i1 false, ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1)
  ret i16 %3
}

; Function Attrs: nounwind uwtable
define internal fastcc void @Thread.Mutex.DarwinImpl.unlock(ptr align 4 nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [8 x i8], align 8
  store ptr %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  %4 = getelementptr inbounds %Thread.Mutex.DarwinImpl, ptr %3, i32 0, i32 0
  call void @os_unfair_lock_unlock(ptr align 4 nonnull %4)
  ret void
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_4018(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = alloca [16 x i8], align 8
  %4 = alloca [16 x i8], align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %4, ptr align 8 %0, i64 16, i1 false)
  %5 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3287, i64 0), i64 7 }, 0
  %6 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3287, i64 0), i64 7 }, 1
  %7 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %4, ptr align 1 readonly nonnull %5, i64 %6)
  %8 = icmp ne i16 %7, 0
  br i1 %8, label %9, label %10

9:
  ret i16 %7

10:
  %11 = getelementptr inbounds { i64 }, ptr %1, i32 0, i32 0
  %12 = load i64, ptr %11, align 8
  %13 = call fastcc i16 @fmt.formatType__anon_4052(i64 %12, ptr align 8 readonly nonnull @30, ptr align 8 readonly nonnull %0, i64 3)
  %14 = icmp ne i16 %13, 0
  br i1 %14, label %15, label %16

15:
  ret i16 %13

16:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %3, ptr align 8 %0, i64 16, i1 false)
  %17 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3287, i64 9), i64 8 }, 0
  %18 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3287, i64 9), i64 8 }, 1
  %19 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %3, ptr align 1 readonly nonnull %17, i64 %18)
  %20 = icmp ne i16 %19, 0
  br i1 %20, label %21, label %22

21:
  ret i16 %19

22:
  ret i16 0
}

; Function Attrs: noreturn nounwind uwtable
declare void @abort() #6

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_4019(ptr align 8 readonly nonnull %0, ptr align 8 readonly nonnull %1) unnamed_addr #0 {
2:
  %3 = alloca [16 x i8], align 8
  %4 = getelementptr inbounds { { ptr, i64 } }, ptr %1, i32 0, i32 0
  %5 = load { ptr, i64 }, ptr %4, align 8
  %6 = extractvalue { ptr, i64 } %5, 0
  %7 = extractvalue { ptr, i64 } %5, 1
  %8 = call fastcc i16 @fmt.formatType__anon_4053(ptr align 1 readonly nonnull %6, i64 %7, ptr align 8 readonly nonnull @31, ptr align 8 readonly nonnull %0, i64 3)
  %9 = icmp ne i16 %8, 0
  br i1 %9, label %10, label %11

10:
  ret i16 %8

11:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %3, ptr align 8 %0, i64 16, i1 false)
  %12 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3300, i64 3), i64 1 }, 0
  %13 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3300, i64 3), i64 1 }, 1
  %14 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %3, ptr align 1 readonly nonnull %12, i64 %13)
  %15 = icmp ne i16 %14, 0
  br i1 %15, label %16, label %17

16:
  ret i16 %14

17:
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @io.Writer.print__anon_4020(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = call fastcc i16 @fmt.format__anon_4054(ptr align 8 readonly nonnull %0)
  ret i16 %2
}

; Function Attrs: nounwind uwtable
define internal fastcc void @"atomic.Value(u32).init"(ptr noalias sret(%"atomic.Value(u32)") nonnull %0, i32 %1) unnamed_addr #0 {
2:
  %3 = getelementptr inbounds %"atomic.Value(u32)", ptr %0, i32 0, i32 0
  store i32 %1, ptr %3, align 4
  ret void
}

; Function Attrs: nounwind uwtable cold
define internal fastcc void @Thread.Futex.wait(ptr align 4 readonly nonnull %0, i32 %1) unnamed_addr #7 {
2:
  %3 = call fastcc i16 @Thread.Futex.DarwinImpl.wait(ptr align 4 readonly nonnull %0, i32 %1, ptr align 8 readonly nonnull @32)
  %4 = icmp eq i16 %3, 0
  br i1 %4, label %6, label %7

5:
  ret void

6:
  br label %5

7:
  switch i16 %3, label %8 [
    i16 27, label %9
  ]

8:
  unreachable

9:
  unreachable
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_4050(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [16 x i8], align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %0, i64 16, i1 false)
  %3 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3318, i64 0), i64 35 }, 0
  %4 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3318, i64 0), i64 35 }, 1
  %5 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %2, ptr align 1 readonly nonnull %3, i64 %4)
  %6 = icmp ne i16 %5, 0
  br i1 %6, label %7, label %8

7:
  ret i16 %5

8:
  ret i16 0
}

; Function Attrs: nounwind uwtable
declare i32 @pthread_threadid_np(ptr align 1 %0, ptr align 8 nonnull %1) #0

; Function Attrs: nounwind uwtable
declare void @os_unfair_lock_lock(ptr align 4 nonnull %0) #0

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Decode2(ptr noalias sret({ i21, i16, [2 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [4 x i8], align 4
  %5 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %6 = insertvalue { ptr, i64 } %5, i64 %2, 1
  %7 = extractvalue { ptr, i64 } %6, 1
  %8 = icmp eq i64 %7, 2
  call fastcc void @debug.assert(i1 %8)
  %9 = extractvalue { ptr, i64 } %6, 0
  %10 = getelementptr inbounds i8, ptr %9, i64 0
  %11 = load i8, ptr %10, align 1
  %12 = and i8 %11, -32
  %13 = icmp eq i8 %12, -64
  call fastcc void @debug.assert(i1 %13)
  %14 = extractvalue { ptr, i64 } %6, 0
  %15 = getelementptr inbounds i8, ptr %14, i64 0
  %16 = load i8, ptr %15, align 1
  %17 = and i8 %16, 31
  %18 = zext i8 %17 to i21
  store i21 %18, ptr %4, align 4
  %19 = extractvalue { ptr, i64 } %6, 0
  %20 = getelementptr inbounds i8, ptr %19, i64 1
  %21 = load i8, ptr %20, align 1
  %22 = and i8 %21, -64
  %23 = icmp ne i8 %22, -128
  br i1 %23, label %40, label %41

24:
  %25 = load i32, ptr %4, align 4
  %26 = trunc i32 %25 to i21
  %27 = zext i5 6 to i21
  %28 = shl i21 %26, %27
  store i21 %28, ptr %4, align 4
  %29 = load i32, ptr %4, align 4
  %30 = trunc i32 %29 to i21
  %31 = extractvalue { ptr, i64 } %6, 0
  %32 = getelementptr inbounds i8, ptr %31, i64 1
  %33 = load i8, ptr %32, align 1
  %34 = and i8 %33, 63
  %35 = zext i8 %34 to i21
  %36 = or i21 %30, %35
  store i21 %36, ptr %4, align 4
  %37 = load i32, ptr %4, align 4
  %38 = trunc i32 %37 to i21
  %39 = icmp ult i21 %38, 128
  br i1 %39, label %47, label %48

40:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @33, i64 8, i1 false)
  ret void

41:
  br label %24

42:
  %43 = load i32, ptr %4, align 4
  %44 = trunc i32 %43 to i21
  %45 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %45, align 2
  %46 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 0
  store i21 %44, ptr %46, align 4
  ret void

47:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @34, i64 8, i1 false)
  ret void

48:
  br label %42
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Decode3(ptr noalias sret({ i21, i16, [2 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [8 x i8], align 4
  %5 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %6 = insertvalue { ptr, i64 } %5, i64 %2, 1
  %7 = extractvalue { ptr, i64 } %6, 0
  %8 = extractvalue { ptr, i64 } %6, 1
  call fastcc void @unicode.utf8Decode3AllowSurrogateHalf(ptr sret({ i21, i16, [2 x i8] }) %4, ptr align 1 readonly nonnull %7, i64 %8)
  %9 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %4, i32 0, i32 1
  %10 = load i16, ptr %9
  %11 = icmp ne i16 %10, 0
  br i1 %11, label %12, label %17

12:
  %13 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %4, i32 0, i32 1
  %14 = load i16, ptr %13
  %15 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 1
  store i16 %14, ptr %15, align 2
  %16 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 0
  ret void

17:
  %18 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %4, i32 0, i32 0
  %19 = load i21, ptr %18, align 4
  %20 = icmp ule i21 55296, %19
  br i1 %20, label %26, label %28

21:
  %22 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %22, align 2
  %23 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 0
  store i21 %19, ptr %23, align 4
  ret void

24:
  %25 = phi i1 [ %27, %26 ], [ false, %28 ]
  br i1 %25, label %29, label %30

26:
  %27 = icmp ule i21 %19, 57343
  br label %24

28:
  br label %24

29:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @35, i64 8, i1 false)
  ret void

30:
  br label %21
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Decode4(ptr noalias sret({ i21, i16, [2 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [4 x i8], align 4
  %5 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %6 = insertvalue { ptr, i64 } %5, i64 %2, 1
  %7 = extractvalue { ptr, i64 } %6, 1
  %8 = icmp eq i64 %7, 4
  call fastcc void @debug.assert(i1 %8)
  %9 = extractvalue { ptr, i64 } %6, 0
  %10 = getelementptr inbounds i8, ptr %9, i64 0
  %11 = load i8, ptr %10, align 1
  %12 = and i8 %11, -8
  %13 = icmp eq i8 %12, -16
  call fastcc void @debug.assert(i1 %13)
  %14 = extractvalue { ptr, i64 } %6, 0
  %15 = getelementptr inbounds i8, ptr %14, i64 0
  %16 = load i8, ptr %15, align 1
  %17 = and i8 %16, 7
  %18 = zext i8 %17 to i21
  store i21 %18, ptr %4, align 4
  %19 = extractvalue { ptr, i64 } %6, 0
  %20 = getelementptr inbounds i8, ptr %19, i64 1
  %21 = load i8, ptr %20, align 1
  %22 = and i8 %21, -64
  %23 = icmp ne i8 %22, -128
  br i1 %23, label %42, label %43

24:
  %25 = load i32, ptr %4, align 4
  %26 = trunc i32 %25 to i21
  %27 = zext i5 6 to i21
  %28 = shl i21 %26, %27
  store i21 %28, ptr %4, align 4
  %29 = load i32, ptr %4, align 4
  %30 = trunc i32 %29 to i21
  %31 = extractvalue { ptr, i64 } %6, 0
  %32 = getelementptr inbounds i8, ptr %31, i64 1
  %33 = load i8, ptr %32, align 1
  %34 = and i8 %33, 63
  %35 = zext i8 %34 to i21
  %36 = or i21 %30, %35
  store i21 %36, ptr %4, align 4
  %37 = extractvalue { ptr, i64 } %6, 0
  %38 = getelementptr inbounds i8, ptr %37, i64 2
  %39 = load i8, ptr %38, align 1
  %40 = and i8 %39, -64
  %41 = icmp ne i8 %40, -128
  br i1 %41, label %62, label %63

42:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @36, i64 8, i1 false)
  ret void

43:
  br label %24

44:
  %45 = load i32, ptr %4, align 4
  %46 = trunc i32 %45 to i21
  %47 = zext i5 6 to i21
  %48 = shl i21 %46, %47
  store i21 %48, ptr %4, align 4
  %49 = load i32, ptr %4, align 4
  %50 = trunc i32 %49 to i21
  %51 = extractvalue { ptr, i64 } %6, 0
  %52 = getelementptr inbounds i8, ptr %51, i64 2
  %53 = load i8, ptr %52, align 1
  %54 = and i8 %53, 63
  %55 = zext i8 %54 to i21
  %56 = or i21 %50, %55
  store i21 %56, ptr %4, align 4
  %57 = extractvalue { ptr, i64 } %6, 0
  %58 = getelementptr inbounds i8, ptr %57, i64 3
  %59 = load i8, ptr %58, align 1
  %60 = and i8 %59, -64
  %61 = icmp ne i8 %60, -128
  br i1 %61, label %80, label %81

62:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @36, i64 8, i1 false)
  ret void

63:
  br label %44

64:
  %65 = load i32, ptr %4, align 4
  %66 = trunc i32 %65 to i21
  %67 = zext i5 6 to i21
  %68 = shl i21 %66, %67
  store i21 %68, ptr %4, align 4
  %69 = load i32, ptr %4, align 4
  %70 = trunc i32 %69 to i21
  %71 = extractvalue { ptr, i64 } %6, 0
  %72 = getelementptr inbounds i8, ptr %71, i64 3
  %73 = load i8, ptr %72, align 1
  %74 = and i8 %73, 63
  %75 = zext i8 %74 to i21
  %76 = or i21 %70, %75
  store i21 %76, ptr %4, align 4
  %77 = load i32, ptr %4, align 4
  %78 = trunc i32 %77 to i21
  %79 = icmp ult i21 %78, 65536
  br i1 %79, label %86, label %87

80:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @36, i64 8, i1 false)
  ret void

81:
  br label %64

82:
  %83 = load i32, ptr %4, align 4
  %84 = trunc i32 %83 to i21
  %85 = icmp ugt i21 %84, -983041
  br i1 %85, label %93, label %94

86:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @37, i64 8, i1 false)
  ret void

87:
  br label %82

88:
  %89 = load i32, ptr %4, align 4
  %90 = trunc i32 %89 to i21
  %91 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %91, align 2
  %92 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 0
  store i21 %90, ptr %92, align 4
  ret void

93:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @38, i64 8, i1 false)
  ret void

94:
  br label %88
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8CodepointSequenceLength(ptr noalias sret({ i16, i3, [1 x i8] }) nonnull %0, i21 %1) unnamed_addr #0 {
2:
  %3 = icmp ult i21 %1, 128
  br i1 %3, label %6, label %7

4:
  %5 = icmp ult i21 %1, 2048
  br i1 %5, label %10, label %11

6:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @24, i64 4, i1 false)
  ret void

7:
  br label %4

8:
  %9 = icmp ult i21 %1, 65536
  br i1 %9, label %14, label %15

10:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @25, i64 4, i1 false)
  ret void

11:
  br label %8

12:
  %13 = icmp ult i21 %1, -983040
  br i1 %13, label %17, label %18

14:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @26, i64 4, i1 false)
  ret void

15:
  br label %12

16:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @28, i64 4, i1 false)
  ret void

17:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @27, i64 4, i1 false)
  ret void

18:
  br label %16
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8EncodeImpl__anon_4051(ptr noalias sret({ i16, i3, [1 x i8] }) nonnull %0, i21 %1, ptr align 1 nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = alloca [16 x i8], align 8
  %6 = alloca [16 x i8], align 8
  %7 = alloca [16 x i8], align 8
  %8 = alloca [16 x i8], align 8
  %9 = alloca [16 x i8], align 8
  %10 = alloca [16 x i8], align 8
  %11 = alloca [16 x i8], align 8
  %12 = alloca [16 x i8], align 8
  %13 = alloca [16 x i8], align 8
  %14 = alloca [16 x i8], align 8
  %15 = alloca [4 x i8], align 2
  %16 = insertvalue { ptr, i64 } poison, ptr %2, 0
  %17 = insertvalue { ptr, i64 } %16, i64 %3, 1
  call fastcc void @unicode.utf8CodepointSequenceLength(ptr sret({ i16, i3, [1 x i8] }) %15, i21 %1)
  %18 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %15, i32 0, i32 0
  %19 = load i16, ptr %18
  %20 = icmp ne i16 %19, 0
  br i1 %20, label %21, label %26

21:
  %22 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %15, i32 0, i32 0
  %23 = load i16, ptr %22
  %24 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %0, i32 0, i32 0
  store i16 %23, ptr %24, align 2
  %25 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %0, i32 0, i32 1
  ret void

26:
  %27 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %15, i32 0, i32 1
  %28 = load i3, ptr %27, align 1
  %29 = extractvalue { ptr, i64 } %17, 1
  %30 = zext i3 %28 to i64
  %31 = icmp uge i64 %29, %30
  call fastcc void @debug.assert(i1 %31)
  switch i3 %28, label %35 [
    i3 1, label %36
    i3 2, label %41
    i3 3, label %55
    i3 -4, label %81
  ]

32:
  %33 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %0, i32 0, i32 0
  store i16 0, ptr %33, align 2
  %34 = getelementptr inbounds { i16, i3, [1 x i8] }, ptr %0, i32 0, i32 1
  store i3 %28, ptr %34, align 1
  ret void

35:
  unreachable

36:
  store { ptr, i64 } %17, ptr %14, align 8
  %37 = load { ptr, i64 }, ptr %14, align 8
  %38 = extractvalue { ptr, i64 } %37, 0
  %39 = getelementptr inbounds i8, ptr %38, i64 0
  %40 = trunc i21 %1 to i8
  store i8 %40, ptr %39, align 1
  br label %32

41:
  store { ptr, i64 } %17, ptr %13, align 8
  %42 = load { ptr, i64 }, ptr %13, align 8
  %43 = extractvalue { ptr, i64 } %42, 0
  %44 = getelementptr inbounds i8, ptr %43, i64 0
  %45 = zext i5 6 to i21
  %46 = lshr i21 %1, %45
  %47 = or i21 192, %46
  %48 = trunc i21 %47 to i8
  store i8 %48, ptr %44, align 1
  store { ptr, i64 } %17, ptr %12, align 8
  %49 = load { ptr, i64 }, ptr %12, align 8
  %50 = extractvalue { ptr, i64 } %49, 0
  %51 = getelementptr inbounds i8, ptr %50, i64 1
  %52 = and i21 %1, 63
  %53 = or i21 128, %52
  %54 = trunc i21 %53 to i8
  store i8 %54, ptr %51, align 1
  br label %32

55:
  %56 = call fastcc i1 @unicode.isSurrogateCodepoint(i21 %1)
  br i1 %56, label %79, label %80

57:
  store { ptr, i64 } %17, ptr %11, align 8
  %58 = load { ptr, i64 }, ptr %11, align 8
  %59 = extractvalue { ptr, i64 } %58, 0
  %60 = getelementptr inbounds i8, ptr %59, i64 0
  %61 = zext i5 12 to i21
  %62 = lshr i21 %1, %61
  %63 = or i21 224, %62
  %64 = trunc i21 %63 to i8
  store i8 %64, ptr %60, align 1
  store { ptr, i64 } %17, ptr %10, align 8
  %65 = load { ptr, i64 }, ptr %10, align 8
  %66 = extractvalue { ptr, i64 } %65, 0
  %67 = getelementptr inbounds i8, ptr %66, i64 1
  %68 = zext i5 6 to i21
  %69 = lshr i21 %1, %68
  %70 = and i21 %69, 63
  %71 = or i21 128, %70
  %72 = trunc i21 %71 to i8
  store i8 %72, ptr %67, align 1
  store { ptr, i64 } %17, ptr %9, align 8
  %73 = load { ptr, i64 }, ptr %9, align 8
  %74 = extractvalue { ptr, i64 } %73, 0
  %75 = getelementptr inbounds i8, ptr %74, i64 2
  %76 = and i21 %1, 63
  %77 = or i21 128, %76
  %78 = trunc i21 %77 to i8
  store i8 %78, ptr %75, align 1
  br label %32

79:
  call void @llvm.memcpy.p0.p0.i64(ptr align 2 %0, ptr align 2 @29, i64 4, i1 false)
  ret void

80:
  br label %57

81:
  store { ptr, i64 } %17, ptr %8, align 8
  %82 = load { ptr, i64 }, ptr %8, align 8
  %83 = extractvalue { ptr, i64 } %82, 0
  %84 = getelementptr inbounds i8, ptr %83, i64 0
  %85 = zext i5 -14 to i21
  %86 = lshr i21 %1, %85
  %87 = or i21 240, %86
  %88 = trunc i21 %87 to i8
  store i8 %88, ptr %84, align 1
  store { ptr, i64 } %17, ptr %7, align 8
  %89 = load { ptr, i64 }, ptr %7, align 8
  %90 = extractvalue { ptr, i64 } %89, 0
  %91 = getelementptr inbounds i8, ptr %90, i64 1
  %92 = zext i5 12 to i21
  %93 = lshr i21 %1, %92
  %94 = and i21 %93, 63
  %95 = or i21 128, %94
  %96 = trunc i21 %95 to i8
  store i8 %96, ptr %91, align 1
  store { ptr, i64 } %17, ptr %6, align 8
  %97 = load { ptr, i64 }, ptr %6, align 8
  %98 = extractvalue { ptr, i64 } %97, 0
  %99 = getelementptr inbounds i8, ptr %98, i64 2
  %100 = zext i5 6 to i21
  %101 = lshr i21 %1, %100
  %102 = and i21 %101, 63
  %103 = or i21 128, %102
  %104 = trunc i21 %103 to i8
  store i8 %104, ptr %99, align 1
  store { ptr, i64 } %17, ptr %5, align 8
  %105 = load { ptr, i64 }, ptr %5, align 8
  %106 = extractvalue { ptr, i64 } %105, 0
  %107 = getelementptr inbounds i8, ptr %106, i64 3
  %108 = and i21 %1, 63
  %109 = or i21 128, %108
  %110 = trunc i21 %109 to i8
  store i8 %110, ptr %107, align 1
  br label %32
}

; Function Attrs: nounwind uwtable
define internal fastcc i1 @unicode.isSurrogateCodepoint(i21 %0) unnamed_addr #0 {
1:
  switch i21 %0, label %4 [
  ]

2:
  %3 = phi i1 [ true, %8 ], [ false, %9 ]
  ret i1 %3

4:
  %5 = icmp uge i21 %0, 55296
  %6 = icmp ule i21 %0, 57343
  %7 = and i1 %5, %6
  br i1 %7, label %8, label %9

8:
  br label %2

9:
  br label %2
}

; Function Attrs: nounwind uwtable
declare void @os_unfair_lock_unlock(ptr align 4 nonnull %0) #0

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatType__anon_4052(i64 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2, i64 %3) unnamed_addr #0 {
4:
  %5 = call fastcc i16 @fmt.formatValue__anon_4058(i64 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2)
  ret i16 %5
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatType__anon_4053(ptr align 1 readonly nonnull %0, i64 %1, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %3, i64 %4) unnamed_addr #0 {
5:
  %6 = alloca [16 x i8], align 8
  %7 = insertvalue { ptr, i64 } poison, ptr %0, 0
  %8 = insertvalue { ptr, i64 } %7, i64 %1, 1
  %9 = icmp eq i64 %4, 0
  br i1 %9, label %14, label %18

10:
  %11 = extractvalue { ptr, i64 } %8, 0
  %12 = extractvalue { ptr, i64 } %8, 1
  %13 = call fastcc i16 @fmt.formatBuf__anon_3980(ptr align 1 readonly nonnull %11, i64 %12, ptr align 8 readonly nonnull %2, ptr align 8 readonly nonnull %3)
  ret i16 %13

14:
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %6, ptr align 8 %3, i64 16, i1 false)
  %15 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3237, i64 0), i64 7 }, 0
  %16 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3237, i64 0), i64 7 }, 1
  %17 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %6, ptr align 1 readonly nonnull %15, i64 %16)
  ret i16 %17

18:
  br label %10
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.format__anon_4054(ptr align 8 readonly nonnull %0) unnamed_addr #0 {
1:
  %2 = alloca [16 x i8], align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %2, ptr align 8 %0, i64 16, i1 false)
  %3 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3692, i64 0), i64 48 }, 0
  %4 = extractvalue { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_3692, i64 0), i64 48 }, 1
  %5 = call fastcc i16 @io.Writer.writeAll(ptr align 8 readonly nonnull %2, ptr align 1 readonly nonnull %3, i64 %4)
  %6 = icmp ne i16 %5, 0
  br i1 %6, label %7, label %8

7:
  ret i16 %5

8:
  ret i16 0
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @Thread.Futex.DarwinImpl.wait(ptr align 4 readonly nonnull %0, i32 %1, ptr align 8 readonly nonnull %2) unnamed_addr #0 {
3:
  %4 = alloca [1 x i8], align 1
  %5 = alloca [8 x i8], align 8
  store i64 0, ptr %5, align 8
  %6 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %2, i32 0, i32 1
  %7 = load i8, ptr %6
  %8 = icmp ne i8 %7, 0
  br i1 %8, label %14, label %18

9:
  store i1 false, ptr %4, align 1
  %10 = zext i32 %1 to i64
  %11 = load i64, ptr %5, align 8
  %12 = call i32 @__ulock_wait2(i32 16777217, ptr align 1 readonly %0, i64 %10, i64 %11, i64 0)
  %13 = icmp sge i32 %12, 0
  br i1 %13, label %22, label %23

14:
  %15 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %2, i32 0, i32 0
  %16 = load i64, ptr %15, align 8
  %17 = icmp ne i64 %16, 0
  call fastcc void @debug.assert(i1 %17)
  store i64 %16, ptr %5, align 8
  br label %9

18:
  br label %9

19:
  %20 = sub nsw i32 0, %12
  %21 = trunc i32 %20 to i16
  switch i16 %21, label %25 [
    i16 4, label %26
    i16 14, label %27
    i16 60, label %28
  ]

22:
  ret i16 0

23:
  br label %19

24:
  ret i16 0

25:
  unreachable

26:
  br label %24

27:
  br label %24

28:
  %29 = getelementptr inbounds { i64, i8, [7 x i8] }, ptr %2, i32 0, i32 1
  %30 = load i8, ptr %29
  %31 = icmp ne i8 %30, 0
  call fastcc void @debug.assert(i1 %31)
  %32 = load i1, ptr %4, align 1
  %33 = xor i1 %32, true
  br i1 %33, label %35, label %36

34:
  br label %24

35:
  ret i16 27

36:
  br label %34
}

; Function Attrs: nounwind uwtable
define internal fastcc void @unicode.utf8Decode3AllowSurrogateHalf(ptr noalias sret({ i21, i16, [2 x i8] }) nonnull %0, ptr align 1 readonly nonnull %1, i64 %2) unnamed_addr #0 {
3:
  %4 = alloca [4 x i8], align 4
  %5 = insertvalue { ptr, i64 } poison, ptr %1, 0
  %6 = insertvalue { ptr, i64 } %5, i64 %2, 1
  %7 = extractvalue { ptr, i64 } %6, 1
  %8 = icmp eq i64 %7, 3
  call fastcc void @debug.assert(i1 %8)
  %9 = extractvalue { ptr, i64 } %6, 0
  %10 = getelementptr inbounds i8, ptr %9, i64 0
  %11 = load i8, ptr %10, align 1
  %12 = and i8 %11, -16
  %13 = icmp eq i8 %12, -32
  call fastcc void @debug.assert(i1 %13)
  %14 = extractvalue { ptr, i64 } %6, 0
  %15 = getelementptr inbounds i8, ptr %14, i64 0
  %16 = load i8, ptr %15, align 1
  %17 = and i8 %16, 15
  %18 = zext i8 %17 to i21
  store i21 %18, ptr %4, align 4
  %19 = extractvalue { ptr, i64 } %6, 0
  %20 = getelementptr inbounds i8, ptr %19, i64 1
  %21 = load i8, ptr %20, align 1
  %22 = and i8 %21, -64
  %23 = icmp ne i8 %22, -128
  br i1 %23, label %42, label %43

24:
  %25 = load i32, ptr %4, align 4
  %26 = trunc i32 %25 to i21
  %27 = zext i5 6 to i21
  %28 = shl i21 %26, %27
  store i21 %28, ptr %4, align 4
  %29 = load i32, ptr %4, align 4
  %30 = trunc i32 %29 to i21
  %31 = extractvalue { ptr, i64 } %6, 0
  %32 = getelementptr inbounds i8, ptr %31, i64 1
  %33 = load i8, ptr %32, align 1
  %34 = and i8 %33, 63
  %35 = zext i8 %34 to i21
  %36 = or i21 %30, %35
  store i21 %36, ptr %4, align 4
  %37 = extractvalue { ptr, i64 } %6, 0
  %38 = getelementptr inbounds i8, ptr %37, i64 2
  %39 = load i8, ptr %38, align 1
  %40 = and i8 %39, -64
  %41 = icmp ne i8 %40, -128
  br i1 %41, label %60, label %61

42:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @39, i64 8, i1 false)
  ret void

43:
  br label %24

44:
  %45 = load i32, ptr %4, align 4
  %46 = trunc i32 %45 to i21
  %47 = zext i5 6 to i21
  %48 = shl i21 %46, %47
  store i21 %48, ptr %4, align 4
  %49 = load i32, ptr %4, align 4
  %50 = trunc i32 %49 to i21
  %51 = extractvalue { ptr, i64 } %6, 0
  %52 = getelementptr inbounds i8, ptr %51, i64 2
  %53 = load i8, ptr %52, align 1
  %54 = and i8 %53, 63
  %55 = zext i8 %54 to i21
  %56 = or i21 %50, %55
  store i21 %56, ptr %4, align 4
  %57 = load i32, ptr %4, align 4
  %58 = trunc i32 %57 to i21
  %59 = icmp ult i21 %58, 2048
  br i1 %59, label %67, label %68

60:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @39, i64 8, i1 false)
  ret void

61:
  br label %44

62:
  %63 = load i32, ptr %4, align 4
  %64 = trunc i32 %63 to i21
  %65 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 1
  store i16 0, ptr %65, align 2
  %66 = getelementptr inbounds { i21, i16, [2 x i8] }, ptr %0, i32 0, i32 0
  store i21 %64, ptr %66, align 4
  ret void

67:
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @40, i64 8, i1 false)
  ret void

68:
  br label %62
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatValue__anon_4058(i64 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2) unnamed_addr #0 {
3:
  %4 = call fastcc i16 @fmt.formatIntValue__anon_4059(i64 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2)
  ret i16 %4
}

; Function Attrs: nounwind uwtable
declare i32 @__ulock_wait2(i32 %0, ptr align 1 readonly %1, i64 %2, i64 %3, i64 %4) #0

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatInt__anon_4060(i64 %0, i8 %1, i1 %2, ptr align 8 readonly nonnull %3, ptr align 8 readonly nonnull %4) unnamed_addr #0 {
5:
  %6 = alloca [16 x i8], align 8
  %7 = alloca [2 x i8], align 1
  %8 = alloca [2 x i8], align 1
  %9 = alloca [8 x i8], align 8
  %10 = alloca [8 x i8], align 8
  %11 = alloca [65 x i8], align 1
  %12 = icmp uge i8 %1, 2
  call fastcc void @debug.assert(i1 %12)
  call void @llvm.memset.p0.i64(ptr align 1 %11, i8 undef, i64 65, i1 false)
  store i64 %0, ptr %10, align 8
  store i64 65, ptr %9, align 8
  %13 = icmp eq i8 %1, 10
  br i1 %13, label %24, label %25

14:
  %15 = load i64, ptr %9, align 8
  %16 = getelementptr inbounds i8, ptr %11, i64 %15
  %17 = sub nuw i64 65, %15
  %18 = insertvalue { ptr, i64 } poison, ptr %16, 0
  %19 = insertvalue { ptr, i64 } %18, i64 %17, 1
  store { ptr, i64 } %19, ptr %6, align 8
  %20 = load { ptr, i64 }, ptr %6, align 8
  %21 = extractvalue { ptr, i64 } %20, 0
  %22 = extractvalue { ptr, i64 } %20, 1
  %23 = call fastcc i16 @fmt.formatBuf__anon_3980(ptr align 1 readonly nonnull %21, i64 %22, ptr align 8 readonly nonnull %3, ptr align 8 readonly nonnull %4)
  ret i16 %23

24:
  br label %29

25:
  br label %59

26:
  %27 = load i64, ptr %10, align 8
  %28 = icmp ult i64 %27, 10
  br i1 %28, label %44, label %52

29:
  %30 = load i64, ptr %10, align 8
  %31 = icmp uge i64 %30, 100
  br i1 %31, label %33, label %42

32:
  br label %29

33:
  %34 = load i64, ptr %9, align 8
  %35 = sub nuw i64 %34, 2
  store i64 %35, ptr %9, align 8
  %36 = load i64, ptr %9, align 8
  %37 = getelementptr inbounds i8, ptr %11, i64 %36
  %38 = load i64, ptr %10, align 8
  %39 = urem i64 %38, 100
  call fastcc void @fmt.digits2(ptr sret([2 x i8]) %8, i64 %39)
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %37, ptr align 1 %8, i64 2, i1 false)
  %40 = load i64, ptr %10, align 8
  %41 = udiv i64 %40, 100
  store i64 %41, ptr %10, align 8
  br label %32

42:
  br label %26

43:
  br label %14

44:
  %45 = load i64, ptr %9, align 8
  %46 = sub nuw i64 %45, 1
  store i64 %46, ptr %9, align 8
  %47 = load i64, ptr %9, align 8
  %48 = getelementptr inbounds [65 x i8], ptr %11, i64 0, i64 %47
  %49 = load i64, ptr %10, align 8
  %50 = trunc i64 %49 to i8
  %51 = add nuw i8 48, %50
  store i8 %51, ptr %48, align 1
  br label %43

52:
  %53 = load i64, ptr %9, align 8
  %54 = sub nuw i64 %53, 2
  store i64 %54, ptr %9, align 8
  %55 = load i64, ptr %9, align 8
  %56 = getelementptr inbounds i8, ptr %11, i64 %55
  %57 = load i64, ptr %10, align 8
  call fastcc void @fmt.digits2(ptr sret([2 x i8]) %7, i64 %57)
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %56, ptr align 1 %7, i64 2, i1 false)
  br label %43

58:
  br label %14

59:
  %60 = load i64, ptr %10, align 8
  %61 = zext i8 %1 to i64
  %62 = urem i64 %60, %61
  %63 = load i64, ptr %9, align 8
  %64 = sub nuw i64 %63, 1
  store i64 %64, ptr %9, align 8
  %65 = load i64, ptr %9, align 8
  %66 = getelementptr inbounds [65 x i8], ptr %11, i64 0, i64 %65
  %67 = trunc i64 %62 to i8
  %68 = call fastcc i8 @fmt.digitToChar(i8 %67, i1 %2)
  store i8 %68, ptr %66, align 1
  %69 = load i64, ptr %10, align 8
  %70 = zext i8 %1 to i64
  %71 = udiv i64 %69, %70
  store i64 %71, ptr %10, align 8
  %72 = load i64, ptr %10, align 8
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %75, label %76

74:
  br label %59

75:
  br label %58

76:
  br label %74
}

; Function Attrs: nounwind uwtable
define internal fastcc i16 @fmt.formatIntValue__anon_4059(i64 %0, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2) unnamed_addr #0 {
3:
  %4 = call fastcc i16 @fmt.formatInt__anon_4060(i64 %0, i8 10, i1 false, ptr align 8 readonly nonnull %1, ptr align 8 readonly nonnull %2)
  ret i16 %4
}

attributes #0 = { nounwind uwtable "frame-pointer"="none" "target-cpu"="skylake" "target-features"="-16bit-mode,-32bit-mode,-3dnow,-3dnowa,+64bit,+adx,+aes,+allow-light-256-bit,-amx-bf16,-amx-complex,-amx-fp16,-amx-int8,-amx-tile,+avx,-avx10.1-256,-avx10.1-512,+avx2,-avx512bf16,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512fp16,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vp2intersect,-avx512vpopcntdq,-avxifma,-avxneconvert,-avxvnni,-avxvnniint16,-avxvnniint8,+bmi,+bmi2,-branchfusion,-ccmp,-cf,-cldemote,+clflushopt,-clwb,-clzero,+cmov,-cmpccxadd,+crc32,+cx16,+cx8,-egpr,-enqcmd,+ermsb,-evex512,+f16c,-false-deps-getmant,-false-deps-lzcnt-tzcnt,-false-deps-mulc,-false-deps-mullq,-false-deps-perm,+false-deps-popcnt,-false-deps-range,-fast-11bytenop,+fast-15bytenop,-fast-7bytenop,-fast-bextr,+fast-gather,-fast-hops,-fast-lzcnt,-fast-movbe,+fast-scalar-fsqrt,-fast-scalar-shift-masks,+fast-shld-rotate,+fast-variable-crosslane-shuffle,+fast-variable-perlane-shuffle,+fast-vector-fsqrt,-fast-vector-shift-masks,-faster-shift-than-shuffle,+fma,-fma4,+fsgsbase,-fsrm,+fxsr,-gfni,-harden-sls-ijmp,-harden-sls-ret,-hreset,-idivl-to-divb,+idivq-to-divl,+invpcid,-kl,-lea-sp,-lea-uses-ag,-lvi-cfi,-lvi-load-hardening,-lwp,+lzcnt,+macrofusion,+mmx,+movbe,-movdir64b,-movdiri,-mwaitx,-ndd,-no-bypass-delay,+no-bypass-delay-blend,+no-bypass-delay-mov,+no-bypass-delay-shuffle,+nopl,-pad-short-functions,+pclmul,-pconfig,-pku,+popcnt,-ppx,-prefer-128-bit,-prefer-256-bit,-prefer-mask-registers,-prefer-movmsk-over-vtest,-prefer-no-gather,-prefer-no-scatter,-prefetchi,-prefetchwt1,+prfchw,-ptwrite,-push2pop2,-raoint,-rdpid,-rdpru,+rdrnd,+rdseed,-retpoline,-retpoline-external-thunk,-retpoline-indirect-branches,-retpoline-indirect-calls,-rtm,+sahf,-sbb-dep-breaking,-serialize,-seses,+sgx,-sha,-sha512,-shstk,+slow-3ops-lea,-slow-incdec,-slow-lea,-slow-pmaddwd,-slow-pmulld,-slow-shld,-slow-two-mem-ops,-slow-unaligned-mem-16,-slow-unaligned-mem-32,-sm3,-sm4,-soft-float,+sse,+sse2,+sse3,+sse4.1,+sse4.2,-sse4a,-sse-unaligned-mem,+ssse3,-tagged-globals,-tbm,-tsxldtrk,-tuning-fast-imm-vector-shift,-uintr,-use-glm-div-sqrt-costs,-use-slm-arith-costs,-usermsr,-vaes,-vpclmulqdq,+vzeroupper,-waitpkg,-wbnoinvd,-widekl,+x87,-xop,+xsave,+xsavec,+xsaveopt,+xsaves" }
attributes #1 = { noreturn nounwind uwtable cold "frame-pointer"="none" "target-cpu"="skylake" "target-features"="-16bit-mode,-32bit-mode,-3dnow,-3dnowa,+64bit,+adx,+aes,+allow-light-256-bit,-amx-bf16,-amx-complex,-amx-fp16,-amx-int8,-amx-tile,+avx,-avx10.1-256,-avx10.1-512,+avx2,-avx512bf16,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512fp16,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vp2intersect,-avx512vpopcntdq,-avxifma,-avxneconvert,-avxvnni,-avxvnniint16,-avxvnniint8,+bmi,+bmi2,-branchfusion,-ccmp,-cf,-cldemote,+clflushopt,-clwb,-clzero,+cmov,-cmpccxadd,+crc32,+cx16,+cx8,-egpr,-enqcmd,+ermsb,-evex512,+f16c,-false-deps-getmant,-false-deps-lzcnt-tzcnt,-false-deps-mulc,-false-deps-mullq,-false-deps-perm,+false-deps-popcnt,-false-deps-range,-fast-11bytenop,+fast-15bytenop,-fast-7bytenop,-fast-bextr,+fast-gather,-fast-hops,-fast-lzcnt,-fast-movbe,+fast-scalar-fsqrt,-fast-scalar-shift-masks,+fast-shld-rotate,+fast-variable-crosslane-shuffle,+fast-variable-perlane-shuffle,+fast-vector-fsqrt,-fast-vector-shift-masks,-faster-shift-than-shuffle,+fma,-fma4,+fsgsbase,-fsrm,+fxsr,-gfni,-harden-sls-ijmp,-harden-sls-ret,-hreset,-idivl-to-divb,+idivq-to-divl,+invpcid,-kl,-lea-sp,-lea-uses-ag,-lvi-cfi,-lvi-load-hardening,-lwp,+lzcnt,+macrofusion,+mmx,+movbe,-movdir64b,-movdiri,-mwaitx,-ndd,-no-bypass-delay,+no-bypass-delay-blend,+no-bypass-delay-mov,+no-bypass-delay-shuffle,+nopl,-pad-short-functions,+pclmul,-pconfig,-pku,+popcnt,-ppx,-prefer-128-bit,-prefer-256-bit,-prefer-mask-registers,-prefer-movmsk-over-vtest,-prefer-no-gather,-prefer-no-scatter,-prefetchi,-prefetchwt1,+prfchw,-ptwrite,-push2pop2,-raoint,-rdpid,-rdpru,+rdrnd,+rdseed,-retpoline,-retpoline-external-thunk,-retpoline-indirect-branches,-retpoline-indirect-calls,-rtm,+sahf,-sbb-dep-breaking,-serialize,-seses,+sgx,-sha,-sha512,-shstk,+slow-3ops-lea,-slow-incdec,-slow-lea,-slow-pmaddwd,-slow-pmulld,-slow-shld,-slow-two-mem-ops,-slow-unaligned-mem-16,-slow-unaligned-mem-32,-sm3,-sm4,-soft-float,+sse,+sse2,+sse3,+sse4.1,+sse4.2,-sse4a,-sse-unaligned-mem,+ssse3,-tagged-globals,-tbm,-tsxldtrk,-tuning-fast-imm-vector-shift,-uintr,-use-glm-div-sqrt-costs,-use-slm-arith-costs,-usermsr,-vaes,-vpclmulqdq,+vzeroupper,-waitpkg,-wbnoinvd,-widekl,+x87,-xop,+xsave,+xsavec,+xsaveopt,+xsaves" }
attributes #2 = { nounwind willreturn nofree nocallback memory(argmem: readwrite) }
attributes #3 = { nounwind willreturn nofree nosync nocallback memory(none) }
attributes #4 = { nounwind willreturn nofree nocallback memory(argmem: write) }
attributes #5 = { nounwind speculatable willreturn nofree nosync nocallback memory(none) }
attributes #6 = { noreturn nounwind uwtable "frame-pointer"="none" "target-cpu"="skylake" "target-features"="-16bit-mode,-32bit-mode,-3dnow,-3dnowa,+64bit,+adx,+aes,+allow-light-256-bit,-amx-bf16,-amx-complex,-amx-fp16,-amx-int8,-amx-tile,+avx,-avx10.1-256,-avx10.1-512,+avx2,-avx512bf16,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512fp16,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vp2intersect,-avx512vpopcntdq,-avxifma,-avxneconvert,-avxvnni,-avxvnniint16,-avxvnniint8,+bmi,+bmi2,-branchfusion,-ccmp,-cf,-cldemote,+clflushopt,-clwb,-clzero,+cmov,-cmpccxadd,+crc32,+cx16,+cx8,-egpr,-enqcmd,+ermsb,-evex512,+f16c,-false-deps-getmant,-false-deps-lzcnt-tzcnt,-false-deps-mulc,-false-deps-mullq,-false-deps-perm,+false-deps-popcnt,-false-deps-range,-fast-11bytenop,+fast-15bytenop,-fast-7bytenop,-fast-bextr,+fast-gather,-fast-hops,-fast-lzcnt,-fast-movbe,+fast-scalar-fsqrt,-fast-scalar-shift-masks,+fast-shld-rotate,+fast-variable-crosslane-shuffle,+fast-variable-perlane-shuffle,+fast-vector-fsqrt,-fast-vector-shift-masks,-faster-shift-than-shuffle,+fma,-fma4,+fsgsbase,-fsrm,+fxsr,-gfni,-harden-sls-ijmp,-harden-sls-ret,-hreset,-idivl-to-divb,+idivq-to-divl,+invpcid,-kl,-lea-sp,-lea-uses-ag,-lvi-cfi,-lvi-load-hardening,-lwp,+lzcnt,+macrofusion,+mmx,+movbe,-movdir64b,-movdiri,-mwaitx,-ndd,-no-bypass-delay,+no-bypass-delay-blend,+no-bypass-delay-mov,+no-bypass-delay-shuffle,+nopl,-pad-short-functions,+pclmul,-pconfig,-pku,+popcnt,-ppx,-prefer-128-bit,-prefer-256-bit,-prefer-mask-registers,-prefer-movmsk-over-vtest,-prefer-no-gather,-prefer-no-scatter,-prefetchi,-prefetchwt1,+prfchw,-ptwrite,-push2pop2,-raoint,-rdpid,-rdpru,+rdrnd,+rdseed,-retpoline,-retpoline-external-thunk,-retpoline-indirect-branches,-retpoline-indirect-calls,-rtm,+sahf,-sbb-dep-breaking,-serialize,-seses,+sgx,-sha,-sha512,-shstk,+slow-3ops-lea,-slow-incdec,-slow-lea,-slow-pmaddwd,-slow-pmulld,-slow-shld,-slow-two-mem-ops,-slow-unaligned-mem-16,-slow-unaligned-mem-32,-sm3,-sm4,-soft-float,+sse,+sse2,+sse3,+sse4.1,+sse4.2,-sse4a,-sse-unaligned-mem,+ssse3,-tagged-globals,-tbm,-tsxldtrk,-tuning-fast-imm-vector-shift,-uintr,-use-glm-div-sqrt-costs,-use-slm-arith-costs,-usermsr,-vaes,-vpclmulqdq,+vzeroupper,-waitpkg,-wbnoinvd,-widekl,+x87,-xop,+xsave,+xsavec,+xsaveopt,+xsaves" }
attributes #7 = { nounwind uwtable cold "frame-pointer"="none" "target-cpu"="skylake" "target-features"="-16bit-mode,-32bit-mode,-3dnow,-3dnowa,+64bit,+adx,+aes,+allow-light-256-bit,-amx-bf16,-amx-complex,-amx-fp16,-amx-int8,-amx-tile,+avx,-avx10.1-256,-avx10.1-512,+avx2,-avx512bf16,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512fp16,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vp2intersect,-avx512vpopcntdq,-avxifma,-avxneconvert,-avxvnni,-avxvnniint16,-avxvnniint8,+bmi,+bmi2,-branchfusion,-ccmp,-cf,-cldemote,+clflushopt,-clwb,-clzero,+cmov,-cmpccxadd,+crc32,+cx16,+cx8,-egpr,-enqcmd,+ermsb,-evex512,+f16c,-false-deps-getmant,-false-deps-lzcnt-tzcnt,-false-deps-mulc,-false-deps-mullq,-false-deps-perm,+false-deps-popcnt,-false-deps-range,-fast-11bytenop,+fast-15bytenop,-fast-7bytenop,-fast-bextr,+fast-gather,-fast-hops,-fast-lzcnt,-fast-movbe,+fast-scalar-fsqrt,-fast-scalar-shift-masks,+fast-shld-rotate,+fast-variable-crosslane-shuffle,+fast-variable-perlane-shuffle,+fast-vector-fsqrt,-fast-vector-shift-masks,-faster-shift-than-shuffle,+fma,-fma4,+fsgsbase,-fsrm,+fxsr,-gfni,-harden-sls-ijmp,-harden-sls-ret,-hreset,-idivl-to-divb,+idivq-to-divl,+invpcid,-kl,-lea-sp,-lea-uses-ag,-lvi-cfi,-lvi-load-hardening,-lwp,+lzcnt,+macrofusion,+mmx,+movbe,-movdir64b,-movdiri,-mwaitx,-ndd,-no-bypass-delay,+no-bypass-delay-blend,+no-bypass-delay-mov,+no-bypass-delay-shuffle,+nopl,-pad-short-functions,+pclmul,-pconfig,-pku,+popcnt,-ppx,-prefer-128-bit,-prefer-256-bit,-prefer-mask-registers,-prefer-movmsk-over-vtest,-prefer-no-gather,-prefer-no-scatter,-prefetchi,-prefetchwt1,+prfchw,-ptwrite,-push2pop2,-raoint,-rdpid,-rdpru,+rdrnd,+rdseed,-retpoline,-retpoline-external-thunk,-retpoline-indirect-branches,-retpoline-indirect-calls,-rtm,+sahf,-sbb-dep-breaking,-serialize,-seses,+sgx,-sha,-sha512,-shstk,+slow-3ops-lea,-slow-incdec,-slow-lea,-slow-pmaddwd,-slow-pmulld,-slow-shld,-slow-two-mem-ops,-slow-unaligned-mem-16,-slow-unaligned-mem-32,-sm3,-sm4,-soft-float,+sse,+sse2,+sse3,+sse4.1,+sse4.2,-sse4a,-sse-unaligned-mem,+ssse3,-tagged-globals,-tbm,-tsxldtrk,-tuning-fast-imm-vector-shift,-uintr,-use-glm-div-sqrt-costs,-use-slm-arith-costs,-usermsr,-vaes,-vpclmulqdq,+vzeroupper,-waitpkg,-wbnoinvd,-widekl,+x87,-xop,+xsave,+xsavec,+xsaveopt,+xsaves" }

Testo modificato

Apri file

@builtin.zig_backend = internal unnamed_addr constant i64 2, align 8
@Target.Cpu.Feature.Set.empty = internal unnamed_addr constant %Target.Cpu.Feature.Set zeroinitializer, align 8
@Target.x86.cpu.skylake = internal unnamed_addr constant %Target.Cpu.Model { { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @__anon_280, i64 0), i64 7 }, %Target.Cpu.Feature.Set { [5 x i64] [i64 4703606015143248112, i64 2308508483300179218, i64 256986653737092120, i64 0, i64 0] } }, align 8
@__anon_280 = internal unnamed_addr constant [8 x i8] c"skylake\00", align 1
@builtin.cpu = internal unnamed_addr constant %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, align 8
@start.simplified_logic = internal unnamed_addr constant i1 false, align 1
@builtin.output_mode = internal unnamed_addr constant i2 0, align 1
@builtin.link_libc = internal unnamed_addr constant i1 true, align 1
@start.native_arch = internal unnamed_addr constant i6 -27, align 1
@os.argv = internal unnamed_addr global { ptr, i64 } undef, align 8
@os.environ = internal unnamed_addr global { ptr, i64 } undef, align 8
@builtin.os = internal unnamed_addr constant { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, align 8
@__anon_1669 = internal unnamed_addr constant { { ptr }, i32, i32 } { { ptr } { ptr getelementptr inbounds (i8, ptr @start.noopSigHandler, i64 0) }, i32 0, i32 0 }, align 8
@__zig_err_name_table = private unnamed_addr constant ptr @68, align 8
@builtin.mode = internal unnamed_addr constant i2 -2, align 1
@debug.runtime_safety = internal unnamed_addr constant i1 false, align 1
@debug.default_enable_segfault_handler = internal unnamed_addr constant i1 false, align 1
@log.default_level = internal unnamed_addr constant i2 0, align 1
@std.options = internal unnamed_addr constant %std.Options { i64 3, i1 false, i2 0, i1 false, i1 true, i1 false, i1 false, i2 -2, [1 x i8] undef }, align 8
@debug.enable_segfault_handler = internal unnamed_addr constant i1 false, align 1
@posix.use_libc = internal unnamed_addr constant i1 true, align 1
@c.native_os = internal unnamed_addr constant i6 10, align 1
@c.darwin.empty_sigset = internal unnamed_addr constant i32 0, align 4
@posix.empty_sigset = internal unnamed_addr constant i32 0, align 4
@builtin.abi = internal unnamed_addr constant i6 0, align 1
@builtin.object_format = internal unnamed_addr constant i4 3, align 1
@Target.DynamicLinker.none = internal unnamed_addr constant %Target.DynamicLinker { [255 x i8] undef, i8 0 }, align 1
@builtin.target = internal unnamed_addr constant { %Target.Cpu, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] }, i6, i4, %Target.DynamicLinker, [6 x i8] } { %Target.Cpu { ptr getelementptr inbounds (i8, ptr @Target.x86.cpu.skylake, i64 0), %Target.Cpu.Feature.Set { [5 x i64] [i64 4705857814956941552, i64 2308508483300179218, i64 275001222971540504, i64 0, i64 0] }, i6 -27, [7 x i8] undef }, { { <{ %SemanticVersion.Range, [56 x i8] }> }, i6, [7 x i8] } { { <{ %SemanticVersion.Range, [56 x i8] }> } { <{ %SemanticVersion.Range, [56 x i8] }> <{ %SemanticVersion.Range { %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer }, %SemanticVersion { i64 14, i64 5, i64 0, { ptr, i64 } zeroinitializer, { ptr, i64 } zeroinitializer } }, [56 x i8] undef }> }, i6 10, [7 x i8] undef }, i6 0, i4 3, %Target.DynamicLinker { [255 x i8] [i8 47, i8 117, i8 115, i8 114, i8 47, i8 108, i8 105, i8 98, i8 47, i8 100, i8 121, i8 108, i8 100, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef], i8 13 }, [6 x i8] undef }, align 8
@_mh_execute_header = weak_odr dso_local global %macho.mach_header_64 undef, align 4
@__anon_2157 = internal unnamed_addr constant [16 x i8] c"(msg truncated)\00", align 1
@Progress.stderr_mutex = internal unnamed_addr global %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8
@0 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@__anon_1474 = internal unnamed_addr constant [5 x i8] c"{d}\0A\00", align 1
@__anon_1704 = internal unnamed_addr constant [40 x i8] c"failed to set noop SIGPIPE handler: {s}\00", align 1
@1 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@2 = private unnamed_addr constant { { ptr, i64 }, i16, [6 x i8] } { { ptr, i64 } undef, i16 5, [6 x i8] undef }, align 8
@Thread.native_os = internal unnamed_addr constant i6 10, align 1
@builtin.single_threaded = internal unnamed_addr constant i1 false, align 1
@Thread.Mutex.Recursive.invalid_thread_id = internal unnamed_addr constant i64 -1, align 8
@Thread.Mutex.Recursive.init = internal unnamed_addr constant %Thread.Mutex.Recursive { i64 -1, i64 0, %Thread.Mutex zeroinitializer, [4 x i8] undef }, align 8
@Progress.global_progress = internal unnamed_addr global %Progress { { %Thread, i8, [7 x i8] } { %Thread undef, i8 0, [7 x i8] undef }, i64 undef, i64 undef, { ptr, i64 } undef, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_parents_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_storage_buffer, i64 0), i64 83 }, { ptr, i64 } { ptr getelementptr inbounds (i8, ptr @Progress.node_freelist_buffer, i64 0), i64 83 }, %fs.File undef, %Thread.ResetEvent zeroinitializer, i32 0, i16 0, i16 0, i2 0, i1 false, i1 false, i8 -1, [4 x i8] undef }, align 8
@3 = private unnamed_addr constant [3 x i8] c"\1B[J", align 1
@io.is_windows = internal unnamed_addr constant i1 false, align 1
@fs.File.is_windows = internal unnamed_addr constant i1 false, align 1
@4 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8
@5 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 7, [6 x i8] undef }, align 8
@6 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 14, [6 x i8] undef }, align 8
@7 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 12, [6 x i8] undef }, align 8
@8 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 2, [6 x i8] undef }, align 8
@9 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 3, [6 x i8] undef }, align 8
@10 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 4, [6 x i8] undef }, align 8
@11 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8
@12 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 8, [6 x i8] undef }, align 8
@13 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 9, [6 x i8] undef }, align 8
@14 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 15, [6 x i8] undef }, align 8
@15 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 6, [6 x i8] undef }, align 8
@fmt.max_format_args = internal unnamed_addr constant i16 32, align 2
@__anon_3237 = internal unnamed_addr constant [8 x i8] c"{ ... }\00", align 1
@debug.panic_stage = internal thread_local unnamed_addr global i64 0, align 8
@debug.panicking = internal unnamed_addr global %"atomic.Value(u8)" zeroinitializer, align 1
@Progress.node_parents_buffer = internal unnamed_addr global [83 x i8] undef, align 1
@Progress.node_storage_buffer = internal unnamed_addr global [83 x %Progress.Node.Storage] undef, align 4
@Progress.node_freelist_buffer = internal unnamed_addr global [83 x i8] undef, align 1
@Progress.is_windows = internal unnamed_addr constant i1 false, align 1
@Thread.use_pthreads = internal unnamed_addr constant i1 true, align 1
@Progress.clear = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3049, i64 0), align 8
@__anon_3049 = internal unnamed_addr constant [4 x i8] c"\1B[J\00", align 1
@posix.native_os = internal unnamed_addr constant i6 10, align 1
@fmt.ANY = internal unnamed_addr constant ptr getelementptr inbounds (i8, ptr @__anon_3156, i64 0), align 8
@__anon_3156 = internal unnamed_addr constant [4 x i8] c"any\00", align 1
@16 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2
@17 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2
@18 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2
@19 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2
@20 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 23, i3 undef, [1 x i8] undef }, align 2
@21 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 24, [6 x i8] undef }, align 8
@__anon_3683 = internal unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1
@22 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 0, i16 0, [6 x i8] undef }, align 8
@23 = private unnamed_addr constant { i64, i16, [6 x i8] } { i64 undef, i16 5, [6 x i8] undef }, align 8
@posix.unexpected_error_tracing = internal unnamed_addr constant i1 false, align 1
@__anon_3790 = internal unnamed_addr constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 1
@unicode.native_endian = internal unnamed_addr constant i1 true, align 1
@mem.native_endian = internal unnamed_addr constant i1 true, align 1
@24 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 1, [1 x i8] undef }, align 2
@25 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 2, [1 x i8] undef }, align 2
@26 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 3, [1 x i8] undef }, align 2
@27 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 0, i3 -4, [1 x i8] undef }, align 2
@28 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 26, i3 undef, [1 x i8] undef }, align 2
@29 = private unnamed_addr constant { i16, i3, [1 x i8] } { i16 25, i3 undef, [1 x i8] undef }, align 2
@unicode.replacement_character = internal unnamed_addr constant i21 65533, align 4
@__anon_3287 = internal unnamed_addr constant [18 x i8] c"thread {} panic: \00", align 1
@30 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@31 = private unnamed_addr constant %fmt.FormatOptions { { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, i21 32, i2 -2, [3 x i8] undef }, align 8
@__anon_3300 = internal unnamed_addr constant [5 x i8] c"{s}\0A\00", align 1
@builtin.strip_debug_info = internal unnamed_addr constant i1 true, align 1
@32 = private unnamed_addr constant { i64, i8, [7 x i8] } { i64 undef, i8 0, [7 x i8] undef }, align 8
@__anon_3318 = internal unnamed_addr constant [36 x i8] c"Panicked during a panic. Aborting.\0A\00", align 1
@33 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@34 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@35 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 21, [2 x i8] undef }, align 4
@36 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@37 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@38 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 22, [2 x i8] undef }, align 4
@__anon_3724 = internal unnamed_addr constant [49 x i8] c"Unable to dump stack trace: debug info stripped\0A\00", align 1
@39 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 19, [2 x i8] undef }, align 4
@40 = private unnamed_addr constant { i21, i16, [2 x i8] } { i21 undef, i16 20, [2 x i8] undef }, align 4
@41 = private unnamed_addr constant [22 x i8] c"OperationNotSupported\00", align 1
@42 = private unnamed_addr constant [10 x i8] c"DiskQuota\00", align 1
@43 = private unnamed_addr constant [11 x i8] c"FileTooBig\00", align 1
@44 = private unnamed_addr constant [12 x i8] c"InputOutput\00", align 1
@45 = private unnamed_addr constant [12 x i8] c"NoSpaceLeft\00", align 1
@46 = private unnamed_addr constant [11 x i8] c"DeviceBusy\00", align 1
@47 = private unnamed_addr constant [16 x i8] c"InvalidArgument\00", align 1
@48 = private unnamed_addr constant [13 x i8] c"AccessDenied\00", align 1
@49 = private unnamed_addr constant [11 x i8] c"BrokenPipe\00", align 1
@50 = private unnamed_addr constant [16 x i8] c"SystemResources\00", align 1
@51 = private unnamed_addr constant [17 x i8] c"OperationAborted\00", align 1
@52 = private unnamed_addr constant [18 x i8] c"NotOpenForWriting\00", align 1
@53 = private unnamed_addr constant [14 x i8] c"LockViolation\00", align 1
@54 = private unnamed_addr constant [11 x i8] c"WouldBlock\00", align 1
@55 = private unnamed_addr constant [22 x i8] c"ConnectionResetByPeer\00", align 1
@56 = private unnamed_addr constant [11 x i8] c"Unexpected\00", align 1
@57 = private unnamed_addr constant [9 x i8] c"Overflow\00", align 1
@58 = private unnamed_addr constant [12 x i8] c"InvalidUtf8\00", align 1
@59 = private unnamed_addr constant [25 x i8] c"Utf8ExpectedContinuation\00", align 1
@60 = private unnamed_addr constant [21 x i8] c"Utf8OverlongEncoding\00", align 1
@61 = private unnamed_addr constant [25 x i8] c"Utf8EncodesSurrogateHalf\00", align 1
@62 = private unnamed_addr constant [22 x i8] c"Utf8CodepointTooLarge\00", align 1
@63 = private unnamed_addr constant [21 x i8] c"Utf8InvalidStartByte\00", align 1
@64 = private unnamed_addr constant [15 x i8] c"TruncatedInput\00", align 1
@65 = private unnamed_addr constant [30 x i8] c"Utf8CannotEncodeSurrogateHalf\00", align 1
@66 = private unnamed_addr constant [18 x i8] c"CodepointTooLarge\00", align 1
@67 = private unnamed_addr constant [8 x i8] c"Timeout\00", align 1
@68 = private unnamed_addr constant [28 x { ptr, i64 }] [{ ptr, i64 } undef, { ptr, i64 } { ptr @41, i64 21 }, { ptr, i64 } { ptr @42, i64 9 }, { ptr, i64 } { ptr @43, i64 10 }, { ptr, i64 } { ptr @44, i64 11 }, { ptr, i64 } { ptr @45, i64 11 }, { ptr, i64 } { ptr @46, i64 10 }, { ptr, i64 } { ptr @47, i64 15 }, { ptr, i64 } { ptr @48, i64 12 }, { ptr, i64 } { ptr @49, i64 10 }, { ptr, i64 } { ptr @50, i64 15 }, { ptr, i64 } { ptr @51, i64 16 }, { ptr, i64 } { ptr @52, i64 17 }, { ptr, i64 } { ptr @53, i64 13 }, { ptr, i64 } { ptr @54, i64 10 }, { ptr, i64 } { ptr @55, i64 21 }, { ptr, i64 } { ptr @56, i64 10 }, { ptr, i64 } { ptr @57, i64 8 }, { ptr, i64 } { ptr @58, i64 11 }, { ptr, i64 } { ptr @59, i64 24 }, { ptr, i64 } { ptr @60, i64 20 }, { ptr, i64 } { ptr @61, i64 24 }, { ptr, i64 } { ptr @62, i64 21 }, { ptr, i64 } { ptr @63, i64 20 }, { ptr, i64 } { ptr @64, i64 14 }, { ptr, i64 } { ptr @65, i64 29 }, { ptr, i64 } { ptr @66, i64 17 }, { ptr, i64 } { ptr @67, i64 7 }], align 8