// Cheese-Cracker: cheese-cracker.github.io

void theCode(){
    ll l = scan;
    ll r = scan;
    if(l == r){
        writeln(0);
        return;
    }
    ll d = r/2 + 1;
    d = max(l, d);
    writeln(r % d);
}

void main(){
    long tests = scan;        // Toggle!
    while(tests--) theCode();
}

/*********  That's All Folks!  *********/
import std.stdio, std.random, std.functional, std.container, std.algorithm;
import std.numeric, std.range, std.typecons, std.string, std.math, std.conv;
string[] tk; T scan(T=long)(){while(!tk.length)tk = readln.split; string a=tk.front; tk.popFront; return a.to!T;}
T[] scanArray(T=long)(){ auto r = readln.split.to!(T[]); return r; }
void show(A...)(A a){ debug{ foreach(t; a){stderr.write(t, "| ");} stderr.writeln; } }
alias ll = long, tup = Tuple!(long, "x",  long, "y");

; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/D/Source_1487/source.d'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/D/Source_1487/source.d"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"

%0 = type opaque
%1 = type opaque
%2 = type { i32, i32, i64, [2 x %object.ModuleInfo*], [7 x i8] }
%object.TypeInfo_Class = type { [20 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, { i64, i8** }, { i64, %object.Interface* }, %object.TypeInfo_Class*, i8*, void (%object.Object*)*, i32, [4 x i8], i8*, { i64, %object.OffsetTypeInfo* }, void (%object.Object*)*, i8* }
%object.Interface = type { %object.TypeInfo_Class*, { i64, i8** }, i64 }
%object.OffsetTypeInfo = type { i64, %object.TypeInfo* }
%object.TypeInfo = type { [19 x i8*]*, i8* }
%object.Object = type { [5 x i8*]*, i8* }
%object.Exception = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.Throwable.TraceInfo = type { [4 x i8*]* }
%object.Throwable = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%object.TypeInfo_Const = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%object.TypeInfo_Struct = type { [19 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64 (i8*)*, i1 (i8*, i8*)*, i32 (i8*, i8*)*, { i64, i8* } (i8*)*, i32, [4 x i8], void (i8*)*, void (i8*)*, i32, [4 x i8], %object.TypeInfo*, %object.TypeInfo*, i8* }
%std.utf.UTFException = type <{ [11 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, [4 x i8], i64, [4 x i32], i64 }>
%std.conv.ConvOverflowException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%std.conv.ConvException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%std.exception.ErrnoException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, i32 }>
%object.ModuleInfo = type { i32, i32 }
%std.stdio.File = type { %std.stdio.File.Impl*, { i64, i8* } }
%std.stdio.File.Impl = type { %core.stdc.stdio._IO_FILE*, i32, i8, [3 x i8], i32, [4 x i8] }
%core.stdc.stdio._IO_FILE = type { i32, [4 x i8], i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %core.stdc.stdio._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], [4 x i8], i8*, i64, i8*, i8*, %core.stdc.stdio._IO_FILE*, i8*, i64, i32, [20 x i8] }
%"std.typecons.Tuple!(long, long).Tuple" = type { i64, i64 }
%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" = type { i64, i64 }
%nest.split = type { i8, [7 x i8], %"std.array.Appender!(string[]).Appender", { i64, i8* }, i64 }
%"std.array.Appender!(string[]).Appender" = type { %"std.array.Appender!(string[]).Appender.Data"* }
%"std.array.Appender!(string[]).Appender.Data" = type { i64, { i64, { i64, i8* }* }, i8, [7 x i8] }
%nest.ensureAddable = type { %"std.array.Appender!(string[]).Appender"*, i64, i64, i64, i64, %core.memory.BlkInfo_ }
%core.memory.BlkInfo_ = type { i8*, i64, i32, [4 x i8] }
%core.memory.GC.Stats = type { i64, i64, i64 }
%nest.decodeImpl = type { i8*, i64 }
%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S" = type { { i64, i8* } }
%"std.array.Appender!string.Appender" = type { %"std.array.Appender!string.Appender.Data"* }
%"std.array.Appender!string.Appender.Data" = type { i64, { i64, i8* }, i8, [7 x i8] }
%nest.put.2 = type { %"std.array.Appender!string.Appender"* }
%nest.ensureAddable.0 = type { %"std.array.Appender!string.Appender"*, i64, i64, i64, i64, %core.memory.BlkInfo_ }
%nest.put.1 = type { %"std.array.Appender!string.Appender"* }
%std.stdio.File.LockingTextWriter = type { %std.stdio.File, i32, i16, [4 x i8], [6 x i8], i64 }
%nest.decodeImpl.4 = type { i8*, i64 }
%nest.signedToTempString = type { { i64, i8* } }

@_D6source2tkAAya = thread_local global { i64, { i64, i8* }* } zeroinitializer, align 8 ; [#uses = 3]
@.str = private unnamed_addr constant [39 x i8] c"Attempt to read from an unopened file.\00" ; [#uses = 1]
@.str.1 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/stdio.d\00" ; [#uses = 1]
@_D9Exception7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D9Exception6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D9Exception6__initZ = external local_unnamed_addr constant %object.Exception, align 8 ; [#uses = 1]
@.str.2 = private unnamed_addr constant [19 x i8] c"Enforcement failed\00" ; [#uses = 1]
@_D12TypeInfo_Axa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D12TypeInfo_Aya6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.3 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/array.d\00" ; [#uses = 1]
@_D11TypeInfo_xm6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_m6__initZ } ; [#uses = 3]
@_D14TypeInfo_Const6__vtblZ = external constant [19 x i8*] ; [#uses = 5]
@_D10TypeInfo_m6__initZ = external global %object.TypeInfo ; [#uses = 1]
@_D14TypeInfo_xAAya6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D14TypeInfo_AxAya6__initZ to %object.TypeInfo*) } ; [#uses = 2]
@_D14TypeInfo_AxAya6__initZ = linkonce_odr global %object.TypeInfo_Array { [19 x i8*]* @_D14TypeInfo_Array6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Const* @_D13TypeInfo_xAya6__initZ to %object.TypeInfo*) } ; [#uses = 1]
@_D14TypeInfo_Array6__vtblZ = external constant [19 x i8*] ; [#uses = 2]
@_D13TypeInfo_xAya6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Aya6__initZ to %object.TypeInfo*) } ; [#uses = 3]
@_D11TypeInfo_xb6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_b6__initZ } ; [#uses = 3]
@_D10TypeInfo_b6__initZ = external global %object.TypeInfo ; [#uses = 1]
@_D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ = linkonce_odr global %object.TypeInfo_Struct { [19 x i8*]* @_D15TypeInfo_Struct6__vtblZ, i8* null, { i64, i8* } { i64 36, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.4, i32 0, i32 0) }, { i64, i8* } { i64 32, i8* null }, i64 (i8*)* bitcast (i64 (%"std.array.Appender!(string[]).Appender.Data"*)* @_D3std5array__T8AppenderTAAyaZQp4Data9__xtoHashFNbNeKxSQCbQCa__TQBxTQBrZQCfQBrZm to i64 (i8*)*), i1 (i8*, i8*)* bitcast (i1 (%"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"*)* @_D3std5array__T8AppenderTAAyaZQp4Data11__xopEqualsFKxSQCaQBz__TQBwTQBqZQCeQBqKxQBaZb to i1 (i8*, i8*)*), i32 (i8*, i8*)* null, { i64, i8* } (i8*)* null, i32 1, [4 x i8] zeroinitializer, void (i8*)* null, void (i8*)* null, i32 8, [4 x i8] zeroinitializer, %object.TypeInfo* null, %object.TypeInfo* null, i8* bitcast ([2 x i64]* @_D6object__T10RTInfoImplVAmA2i32i4ZQxyG2m to i8*) } ; [#uses = 1]
@_D15TypeInfo_Struct6__vtblZ = external constant [19 x i8*] ; [#uses = 2]
@.str.4 = private unnamed_addr constant [37 x i8] c"S3std5array__T8AppenderTAAyaZQp4Data\00" ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i32i4ZQxyG2m = weak_odr constant [2 x i64] [i64 32, i64 4], align 8 ; [#uses = 1]
@.str.5 = private unnamed_addr constant [58 x i8] c"the reallocation would exceed the available pointer range\00" ; [#uses = 1]
@.str.6 = private unnamed_addr constant [54 x i8] c"Attempting to shrink Appender with newlength > length\00" ; [#uses = 1]
@.str.7 = private unnamed_addr constant [60 x i8] c"Attempting to shrink empty Appender with non-zero newlength\00" ; [#uses = 1]
@.str.8 = private unnamed_addr constant [58 x i8] c"Attempting to fetch the front of an empty array of string\00" ; [#uses = 1]
@.str.9 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/primitives.d\00" ; [#uses = 1]
@_D13TypeInfo_AAya6__initZ = linkonce_odr global %object.TypeInfo_Array { [19 x i8*]* @_D14TypeInfo_Array6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Aya6__initZ to %object.TypeInfo*) } ; [#uses = 1]
@.str.10 = private unnamed_addr constant [9 x i8] c"string[]\00" ; [#uses = 1]
@.str.11 = private unnamed_addr constant [68 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/core/internal/array/utils.d\00" ; [#uses = 1]
@.str.12 = private unnamed_addr constant [56 x i8] c"Attempting to fetch the front of an empty array of char\00" ; [#uses = 1]
@.str.13 = private unnamed_addr constant [45 x i8] c"Attempted to decode past the end of a string\00" ; [#uses = 1]
@.str.14 = private unnamed_addr constant [50 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/utf.d\00" ; [#uses = 1]
@.str.15 = private unnamed_addr constant [23 x i8] c"Invalid UTF-8 sequence\00" ; [#uses = 1]
@_D3std3utf12UTFException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 8]
@_D3std3utf12UTFException6__vtblZ = external constant [11 x i8*] ; [#uses = 3]
@_D3std3utf12UTFException6__initZ = external local_unnamed_addr constant %std.utf.UTFException, align 8 ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i16i2ZQxyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 16, i64 2], align 8 ; [#uses = 0]
@.str.16 = private unnamed_addr constant [60 x i8] c"Attempting to popFront() past the end of an array of string\00" ; [#uses = 1]
@_D3std4conv21ConvOverflowException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D3std4conv21ConvOverflowException6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D3std4conv21ConvOverflowException6__initZ = external local_unnamed_addr constant %std.conv.ConvOverflowException, align 8 ; [#uses = 1]
@.str.17 = private unnamed_addr constant [32 x i8] c"Overflow in integral conversion\00" ; [#uses = 1]
@.str.18 = private unnamed_addr constant [51 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/conv.d\00" ; [#uses = 1]
@.str.19 = private unnamed_addr constant [57 x i8] c"Attempting to fetch the front of an empty array of ubyte\00" ; [#uses = 1]
@.str.20 = private unnamed_addr constant [59 x i8] c"Attempting to popFront() past the end of an array of ubyte\00" ; [#uses = 1]
@.str.21 = private unnamed_addr constant [70 x i8] c"Unexpected end of input when converting from type string to type long\00" ; [#uses = 1]
@.str.22 = private unnamed_addr constant [62 x i8] c"Unexpected '\\n' when converting from type string to type long\00" ; [#uses = 1]
@.str.23 = private unnamed_addr constant [13 x i8] c"Unexpected '\00" ; [#uses = 1]
@.str.24 = private unnamed_addr constant [48 x i8] c"' when converting from type string to type long\00" ; [#uses = 1]
@_D3std4conv13ConvException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D3std4conv13ConvException6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D3std4conv13ConvException6__initZ = external local_unnamed_addr constant %std.conv.ConvException, align 8 ; [#uses = 1]
@_D12TypeInfo_xAa6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*) } ; [#uses = 2]
@_D44TypeInfo_S3std5array__T8AppenderTAyaZQo4Data6__initZ = linkonce_odr global %object.TypeInfo_Struct { [19 x i8*]* @_D15TypeInfo_Struct6__vtblZ, i8* null, { i64, i8* } { i64 35, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.25, i32 0, i32 0) }, { i64, i8* } { i64 32, i8* null }, i64 (i8*)* bitcast (i64 (%"std.array.Appender!string.Appender.Data"*)* @_D3std5array__T8AppenderTAyaZQo4Data9__xtoHashFNbNeKxSQCaQBz__TQBwTQBqZQCeQBrZm to i64 (i8*)*), i1 (i8*, i8*)* bitcast (i1 (%"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"*)* @_D3std5array__T8AppenderTAyaZQo4Data11__xopEqualsFKxSQBzQBy__TQBvTQBpZQCdQBqKxQBaZb to i1 (i8*, i8*)*), i32 (i8*, i8*)* null, { i64, i8* } (i8*)* null, i32 1, [4 x i8] zeroinitializer, void (i8*)* null, void (i8*)* null, i32 8, [4 x i8] zeroinitializer, %object.TypeInfo* null, %object.TypeInfo* null, i8* bitcast ([2 x i64]* @_D6object__T10RTInfoImplVAmA2i32i4ZQxyG2m to i8*) } ; [#uses = 1]
@.str.25 = private unnamed_addr constant [36 x i8] c"S3std5array__T8AppenderTAyaZQo4Data\00" ; [#uses = 1]
@_D11TypeInfo_Aa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.26 = private unnamed_addr constant [7 x i8] c"char[]\00" ; [#uses = 1]
@.str.27 = private unnamed_addr constant [41 x i8] c"Encoding a surrogate code point in UTF-8\00" ; [#uses = 1]
@.str.28 = private unnamed_addr constant [40 x i8] c"Encoding an invalid code point in UTF-8\00" ; [#uses = 1]
@_D6object9Throwable7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 2]
@_D6object__T10RTInfoImplVAmA2i8i1ZQwyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 8, i64 1], align 8 ; [#uses = 0]
@.str.29 = private unnamed_addr constant [41 x i8] c"Encoding an invalid code point in UTF-32\00" ; [#uses = 1]
@.str.30 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/core/internal/string.d\00" ; [#uses = 1]
@_D3std9exception14ErrnoException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D3std9exception14ErrnoException6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D3std9exception14ErrnoException6__initZ = external local_unnamed_addr constant %std.exception.ErrnoException, align 8 ; [#uses = 1]
@_D3std4conv12__ModuleInfoZ = external global %0  ; [#uses = 1]
@_D4core6memory12__ModuleInfoZ = external global %1 ; [#uses = 1]
@_D6source12__ModuleInfoZ = global %2 { i32 -2147482624, i32 0, i64 2, [2 x %object.ModuleInfo*] [%object.ModuleInfo* bitcast (%0* @_D3std4conv12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%1* @_D4core6memory12__ModuleInfoZ to %object.ModuleInfo*)], [7 x i8] c"source\00" } ; [#uses = 1]
@_D6source11__moduleRefZ = linkonce_odr hidden global %object.ModuleInfo* bitcast (%2* @_D6source12__ModuleInfoZ to %object.ModuleInfo*), section "__minfo" ; [#uses = 1]
@__start___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@__stop___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@ldc.dso_slot = linkonce_odr hidden global i8* null ; [#uses = 1]
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.global_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.used = appending global [1 x i8*] [i8* bitcast (%object.ModuleInfo** @_D6source11__moduleRefZ to i8*)], section "llvm.metadata" ; [#uses = 0]

; [#uses = 1]
; Function Attrs: uwtable
define void @_D6source7theCodeFZv() local_unnamed_addr #0 {
  %1 = tail call i64 @_D6source__T4scanTlZQiFZl() #2 ; [#uses = 3]
  %2 = tail call i64 @_D6source__T4scanTlZQiFZl() #2 ; [#uses = 3]
  %3 = icmp eq i64 %1, %2                         ; [#uses = 1]
  br i1 %3, label %if, label %endif

if:                                               ; preds = %0
  tail call void @_D3std5stdio__T7writelnTiZQlFNfiZv(i32 0) #2
  ret void

endif:                                            ; preds = %0
  %4 = sdiv i64 %2, 2                             ; [#uses = 2]
  %5 = add nsw i64 %4, 1                          ; [#uses = 1]
  %.not = icmp sgt i64 %1, %4                     ; [#uses = 1]
  %b_arg.a_arg.i = select i1 %.not, i64 %1, i64 %5 ; [#uses = 1]
  %6 = srem i64 %2, %b_arg.a_arg.i                ; [#uses = 1]
  tail call void @_D3std5stdio__T7writelnTlZQlFNflZv(i64 %6) #2
  ret void
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr i64 @_D6source__T4scanTlZQiFZl() local_unnamed_addr #0 {
  %.len.pr = load i64, i64* getelementptr inbounds ({ i64, { i64, i8* }* }, { i64, { i64, i8* }* }* @_D6source2tkAAya, i64 0, i32 0), align 8 ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %forbody, %0
  %.len = phi i64 [ %.len1, %forbody ], [ %.len.pr, %0 ] ; [#uses = 2, type = i64]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  br i1 %.not, label %forbody, label %endfor

forbody:                                          ; preds = %forcond
  %1 = tail call { i64, i8* } @_D3std5stdio__T6readlnTAyaZQmFwZQj(i32 10) #2 ; [#uses = 1]
  %2 = tail call { i64, { i64, i8* }* } @_D3std5array__T5splitTAyaZQlFNaNfQlZAQp({ i64, i8* } %1) #2 ; [#uses = 2]
  %.ptr = extractvalue { i64, { i64, i8* }* } %2, 1 ; [#uses = 1]
  %.len1 = extractvalue { i64, { i64, i8* }* } %2, 0 ; [#uses = 2]
  store i64 %.len1, i64* getelementptr inbounds ({ i64, { i64, i8* }* }, { i64, { i64, i8* }* }* @_D6source2tkAAya, i64 0, i32 0), align 8
  store { i64, i8* }* %.ptr, { i64, i8* }** getelementptr inbounds ({ i64, { i64, i8* }* }, { i64, { i64, i8* }* }* @_D6source2tkAAya, i64 0, i32 1), align 8
  br label %forcond

endfor:                                           ; preds = %forcond
  %3 = insertvalue { i64, { i64, i8* }* } undef, i64 %.len, 0 ; [#uses = 1]
  %.unpack4 = load { i64, i8* }*, { i64, i8* }** getelementptr inbounds ({ i64, { i64, i8* }* }, { i64, { i64, i8* }* }* @_D6source2tkAAya, i64 0, i32 1), align 8 ; [#uses = 1]
  %4 = insertvalue { i64, { i64, i8* }* } %3, { i64, i8* }* %.unpack4, 1 ; [#uses = 1]
  %5 = tail call { i64, i8* }* @_D3std5range10primitives__T5frontTAyaZQlFNaNbNcNdNiNfMNkANgAyaZNgQg({ i64, { i64, i8* }* } %4) #2 ; [#uses = 2]
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %5, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr2 = load i8*, i8** %6, align 8             ; [#uses = 1]
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %5, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len3 = load i64, i64* %7, align 8             ; [#uses = 1]
  tail call void @_D3std5range10primitives__T8popFrontTAyaZQoFNaNbNiNfMKANgAyaZv({ i64, { i64, i8* }* }* nonnull dereferenceable(16) @_D6source2tkAAya) #2
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.len3, 0 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.ptr2, 1 ; [#uses = 1]
  %8 = tail call i64 @_D3std4conv__T6toImplTlTAyaZQoFNaNfQlZl({ i64, i8* } %.fca.1.insert) #2 ; [#uses = 1]
  ret i64 %8
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio__T7writelnTiZQlFNfiZv(i32 %_param_0_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %__tmpfordtor215 = alloca %std.stdio.File, align 8 ; [#uses = 4, size/byte = 24]
  call void @_D3std5stdio13trustedStdoutFNdNeZSQBgQBf4File(%std.stdio.File* noalias nonnull sret align 8 %__tmpfordtor215) #2
  invoke void @_D3std5stdio4File__T5writeTiTaZQlMFNfiaZv(%std.stdio.File* nonnull %__tmpfordtor215, i8 zeroext 10, i32 %_param_0_arg) #2
          to label %toElem.success unwind label %eh.resume

toElem.success:                                   ; preds = %0
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor215) #2
  ret void

eh.resume:                                        ; preds = %0
  %1 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %2 = extractvalue { i8*, i32 } %1, 0            ; [#uses = 1]
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor215) #2
  call void @_Unwind_Resume(i8* %2)
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm10comparison__T3maxTlTlZQjFNaNbNiNfllZl(i64 %b_arg, i64 %a_arg) local_unnamed_addr #0 {
condend:
  %0 = icmp slt i64 %a_arg, %b_arg                ; [#uses = 1]
  %b_arg.a_arg = select i1 %0, i64 %b_arg, i64 %a_arg ; [#uses = 1]
  ret i64 %b_arg.a_arg
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio__T7writelnTlZQlFNflZv(i64 %_param_0_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %__tmpfordtor217 = alloca %std.stdio.File, align 8 ; [#uses = 4, size/byte = 24]
  call void @_D3std5stdio13trustedStdoutFNdNeZSQBgQBf4File(%std.stdio.File* noalias nonnull sret align 8 %__tmpfordtor217) #2
  invoke void @_D3std5stdio4File__T5writeTlTaZQlMFNflaZv(%std.stdio.File* nonnull %__tmpfordtor217, i8 zeroext 10, i64 %_param_0_arg) #2
          to label %toElem.success unwind label %eh.resume

toElem.success:                                   ; preds = %0
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor217) #2
  ret void

eh.resume:                                        ; preds = %0
  %1 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %2 = extractvalue { i8*, i32 } %1, 0            ; [#uses = 1]
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor217) #2
  call void @_Unwind_Resume(i8* %2)
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #1 {
  %1 = tail call i64 @_D6source__T4scanTlZQiFZl() #2 ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %forbody, %0
  %tests.0 = phi i64 [ %1, %0 ], [ %2, %forbody ] ; [#uses = 2, type = i64]
  %.not = icmp eq i64 %tests.0, 0                 ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody

forbody:                                          ; preds = %forcond
  %2 = add i64 %tests.0, -1                       ; [#uses = 1]
  tail call void @_D6source7theCodeFZv() #0
  br label %forcond

endfor:                                           ; preds = %forcond
  ret i32 0
}

; [#uses = 1]
declare i32 @_d_run_main(i32, i8**, i8*) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define i32 @main(i32 %argc_arg, i8** %argv_arg) local_unnamed_addr #0 {
  %1 = tail call i32 @_d_run_main(i32 %argc_arg, i8** %argv_arg, i8* bitcast (i32 ({ i64, { i64, i8* }* })* @_Dmain to i8*)) #2 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.typecons.Tuple!(long, long).Tuple"* @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc12_Tuple_superMNgFNaNbNcNdNiNeZNgSQDdQDc__TQCwTlTlZQDe(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = bitcast %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg to %"std.typecons.Tuple!(long, long).Tuple"* ; [#uses = 1]
  ret %"std.typecons.Tuple!(long, long).Tuple"* %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc6__ctorMFNaNbNcNiNfllZSQCsQCr__TQClTlVQCia1_78TlVQCta1_79ZQDl(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull returned %.this_arg, i64 %_param_1_arg, i64 %_param_0_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %_param_0_arg, i64* %1, align 8
  %2 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  store i64 %_param_1_arg, i64* %2, align 8
  ret %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc6toHashMxFNaNbNiNfZm(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 3]
  %3 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = add i64 %4, 2654435769                     ; [#uses = 1]
  %6 = shl i64 %2, 6                              ; [#uses = 1]
  %7 = add i64 %5, %6                             ; [#uses = 1]
  %8 = lshr i64 %2, 2                             ; [#uses = 1]
  %9 = add i64 %7, %8                             ; [#uses = 1]
  %10 = xor i64 %9, %2                            ; [#uses = 1]
  ret i64 %10
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D4core8internal4hash__T6hashOfTlZQkFNaNbNiNexlZm(i64 %val_arg) local_unnamed_addr #0 {
  ret i64 %val_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc11__xopEqualsFKxSQCmQCl__TQCfTlVQCca1_78TlVQCna1_79ZQDfKxQBpZb(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* dereferenceable(16) %q, %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %q, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = icmp eq i64 %2, %.unpack                   ; [#uses = 1]
  br i1 %3, label %andand.i, label %_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T8opEqualsTxSQCkQCj__TQCdTlVQCaa1_78TlVQCla1_79ZQDdZQBzMxFNaNbNiNfxQCdZb.exit

andand.i:                                         ; preds = %0
  %.elt1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %q, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %.unpack2 = load i64, i64* %.elt1, align 8      ; [#uses = 1]
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %p, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 1]
  %6 = icmp eq i64 %5, %.unpack2                  ; [#uses = 1]
  br label %_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T8opEqualsTxSQCkQCj__TQCdTlVQCaa1_78TlVQCla1_79ZQDdZQBzMxFNaNbNiNfxQCdZb.exit

_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T8opEqualsTxSQCkQCj__TQCdTlVQCaa1_78TlVQCla1_79ZQDdZQBzMxFNaNbNiNfxQCdZb.exit: ; preds = %0, %andand.i
  %andandval.i = phi i1 [ false, %0 ], [ %6, %andand.i ] ; [#uses = 1, type = i1]
  ret i1 %andandval.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T8opEqualsTxSQCkQCj__TQCdTlVQCaa1_78TlVQCla1_79ZQDdZQBzMxFNaNbNiNfxQCdZb(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg) local_unnamed_addr #0 {
  %rhs_arg.fca.0.extract = extractvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg, 0 ; [#uses = 1]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = icmp eq i64 %2, %rhs_arg.fca.0.extract     ; [#uses = 1]
  br i1 %3, label %andand, label %andandend

andand:                                           ; preds = %0
  %rhs_arg.fca.1.extract = extractvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg, 1 ; [#uses = 1]
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 1]
  %6 = icmp eq i64 %5, %rhs_arg.fca.1.extract     ; [#uses = 1]
  br label %andandend

andandend:                                        ; preds = %andand, %0
  %andandval = phi i1 [ false, %0 ], [ %6, %andand ] ; [#uses = 1, type = i1]
  ret i1 %andandval
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc8__xopCmpFKxSQCiQCh__TQCbTlVQBya1_78TlVQCja1_79ZQDbKxQBpZi(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* dereferenceable(16) %q, %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %p, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %.unpack2 = load i64, i64* %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %1, i64 %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i32 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T5opCmpTxSQChQCg__TQCaTlVQBxa1_78TlVQCia1_79ZQDaZQBwMxFNaNbNiNfxQCdZi(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull %q, %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %2) #2 ; [#uses = 1]
  ret i32 %3
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTlVAyaa1_78TlVQla1_79ZQBc__T5opCmpTxSQChQCg__TQCaTlVQBxa1_78TlVQCia1_79ZQDaZQBwMxFNaNbNiNfxQCdZi(%"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg) local_unnamed_addr #0 {
  %rhs_arg.fca.0.extract = extractvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg, 0 ; [#uses = 2]
  %rhs_arg.fca.1.extract = extractvalue %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple" %rhs_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 2]
  %.not = icmp eq i64 %2, %rhs_arg.fca.0.extract  ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %3 = icmp slt i64 %2, %rhs_arg.fca.0.extract    ; [#uses = 1]
  %. = select i1 %3, i32 -1, i32 1                ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %endif, %if, %if2
  %condtmp.0.sroa.speculated = phi i32 [ %.18, %if2 ], [ %., %if ], [ 0, %endif ] ; [#uses = 1, type = i32]
  ret i32 %condtmp.0.sroa.speculated

endif:                                            ; preds = %0
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple", %"std.typecons.Tuple!(long, \22x\22, long, \22y\22).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 2]
  %.not17 = icmp eq i64 %5, %rhs_arg.fca.1.extract ; [#uses = 1]
  br i1 %.not17, label %condend, label %if2

if2:                                              ; preds = %endif
  %6 = icmp slt i64 %5, %rhs_arg.fca.1.extract    ; [#uses = 1]
  %.18 = select i1 %6, i32 -1, i32 1              ; [#uses = 1]
  br label %condend
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.typecons.Tuple!(long, long).Tuple"* @_D3std8typecons__T5TupleTlTlZQl6__ctorMFNaNbNcNiNfllZSQCaQBz__TQBtTlTlZQCb(%"std.typecons.Tuple!(long, long).Tuple"* nonnull returned %.this_arg, i64 %_param_1_arg, i64 %_param_0_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %_param_0_arg, i64* %1, align 8
  %2 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  store i64 %_param_1_arg, i64* %2, align 8
  ret %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std8typecons__T5TupleTlTlZQl6toHashMxFNaNbNiNfZm(%"std.typecons.Tuple!(long, long).Tuple"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 3]
  %3 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = add i64 %4, 2654435769                     ; [#uses = 1]
  %6 = shl i64 %2, 6                              ; [#uses = 1]
  %7 = add i64 %5, %6                             ; [#uses = 1]
  %8 = lshr i64 %2, 2                             ; [#uses = 1]
  %9 = add i64 %7, %8                             ; [#uses = 1]
  %10 = xor i64 %9, %2                            ; [#uses = 1]
  ret i64 %10
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTlTlZQl11__xopEqualsFKxSQBuQBt__TQBnTlTlZQBvKxQxZb(%"std.typecons.Tuple!(long, long).Tuple"* dereferenceable(16) %q, %"std.typecons.Tuple!(long, long).Tuple"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %q, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = icmp eq i64 %2, %.unpack                   ; [#uses = 1]
  br i1 %3, label %andand.i, label %_D3std8typecons__T5TupleTlTlZQl__T8opEqualsTxSQBsQBr__TQBlTlTlZQBtZQBhMxFNaNbNiNfxQBlZb.exit

andand.i:                                         ; preds = %0
  %.elt1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %q, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %.unpack2 = load i64, i64* %.elt1, align 8      ; [#uses = 1]
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %p, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 1]
  %6 = icmp eq i64 %5, %.unpack2                  ; [#uses = 1]
  br label %_D3std8typecons__T5TupleTlTlZQl__T8opEqualsTxSQBsQBr__TQBlTlTlZQBtZQBhMxFNaNbNiNfxQBlZb.exit

_D3std8typecons__T5TupleTlTlZQl__T8opEqualsTxSQBsQBr__TQBlTlTlZQBtZQBhMxFNaNbNiNfxQBlZb.exit: ; preds = %0, %andand.i
  %andandval.i = phi i1 [ false, %0 ], [ %6, %andand.i ] ; [#uses = 1, type = i1]
  ret i1 %andandval.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTlTlZQl__T8opEqualsTxSQBsQBr__TQBlTlTlZQBtZQBhMxFNaNbNiNfxQBlZb(%"std.typecons.Tuple!(long, long).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg) local_unnamed_addr #0 {
  %rhs_arg.fca.0.extract = extractvalue %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg, 0 ; [#uses = 1]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = icmp eq i64 %2, %rhs_arg.fca.0.extract     ; [#uses = 1]
  br i1 %3, label %andand, label %andandend

andand:                                           ; preds = %0
  %rhs_arg.fca.1.extract = extractvalue %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg, 1 ; [#uses = 1]
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 1]
  %6 = icmp eq i64 %5, %rhs_arg.fca.1.extract     ; [#uses = 1]
  br label %andandend

andandend:                                        ; preds = %andand, %0
  %andandval = phi i1 [ false, %0 ], [ %6, %andand ] ; [#uses = 1, type = i1]
  ret i1 %andandval
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTlTlZQl8__xopCmpFKxSQBqQBp__TQBjTlTlZQBrKxQxZi(%"std.typecons.Tuple!(long, long).Tuple"* dereferenceable(16) %q, %"std.typecons.Tuple!(long, long).Tuple"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue %"std.typecons.Tuple!(long, long).Tuple" undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %p, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %.unpack2 = load i64, i64* %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue %"std.typecons.Tuple!(long, long).Tuple" %1, i64 %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i32 @_D3std8typecons__T5TupleTlTlZQl__T5opCmpTxSQBpQBo__TQBiTlTlZQBqZQBeMxFNaNbNiNfxQBlZi(%"std.typecons.Tuple!(long, long).Tuple"* nonnull %q, %"std.typecons.Tuple!(long, long).Tuple" %2) #2 ; [#uses = 1]
  ret i32 %3
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTlTlZQl__T5opCmpTxSQBpQBo__TQBiTlTlZQBqZQBeMxFNaNbNiNfxQBlZi(%"std.typecons.Tuple!(long, long).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg) local_unnamed_addr #0 {
  %rhs_arg.fca.0.extract = extractvalue %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg, 0 ; [#uses = 2]
  %rhs_arg.fca.1.extract = extractvalue %"std.typecons.Tuple!(long, long).Tuple" %rhs_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 2]
  %.not = icmp eq i64 %2, %rhs_arg.fca.0.extract  ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %3 = icmp slt i64 %2, %rhs_arg.fca.0.extract    ; [#uses = 1]
  %. = select i1 %3, i32 -1, i32 1                ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %endif, %if, %if2
  %condtmp.0.sroa.speculated = phi i32 [ %.18, %if2 ], [ %., %if ], [ 0, %endif ] ; [#uses = 1, type = i32]
  ret i32 %condtmp.0.sroa.speculated

endif:                                            ; preds = %0
  %4 = getelementptr inbounds %"std.typecons.Tuple!(long, long).Tuple", %"std.typecons.Tuple!(long, long).Tuple"* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %5 = load i64, i64* %4, align 8                 ; [#uses = 2]
  %.not17 = icmp eq i64 %5, %rhs_arg.fca.1.extract ; [#uses = 1]
  br i1 %.not17, label %condend, label %if2

if2:                                              ; preds = %endif
  %6 = icmp slt i64 %5, %rhs_arg.fca.1.extract    ; [#uses = 1]
  %.18 = select i1 %6, i32 -1, i32 1              ; [#uses = 1]
  br label %condend
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %rhs_arg, { i64, i8* } %lhs_arg) local_unnamed_addr #0 {
  %lhs_arg.fca.0.extract = extractvalue { i64, i8* } %lhs_arg, 0 ; [#uses = 3]
  %lhs_arg.fca.1.extract = extractvalue { i64, i8* } %lhs_arg, 1 ; [#uses = 1]
  %rhs_arg.fca.0.extract = extractvalue { i64, i8* } %rhs_arg, 0 ; [#uses = 1]
  %rhs_arg.fca.1.extract = extractvalue { i64, i8* } %rhs_arg, 1 ; [#uses = 1]
  %.not = icmp eq i64 %lhs_arg.fca.0.extract, %rhs_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0, %endif, %oror
  %merge = phi i1 [ false, %0 ], [ true, %endif ], [ %2, %oror ] ; [#uses = 1, type = i1]
  ret i1 %merge

endif:                                            ; preds = %0
  %1 = icmp eq i64 %lhs_arg.fca.0.extract, 0      ; [#uses = 1]
  br i1 %1, label %if, label %oror

oror:                                             ; preds = %endif
  %bcmp = tail call i32 @bcmp(i8* %lhs_arg.fca.1.extract, i8* %rhs_arg.fca.1.extract, i64 %lhs_arg.fca.0.extract) ; [#uses = 1]
  %2 = icmp eq i32 %bcmp, 0                       ; [#uses = 1]
  br label %if
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__T5splitTAyaZQlFNaNfQlZAQp({ i64, i8* } %s_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.split, align 8           ; [#uses = 6, size/byte = 40]
  %s_arg.fca.0.extract = extractvalue { i64, i8* } %s_arg, 0 ; [#uses = 1]
  %s_arg.fca.1.extract = extractvalue { i64, i8* } %s_arg, 1 ; [#uses = 1]
  %inword = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 0 ; [#uses = 3, type = i8*]
  %result = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 2 ; [#uses = 2, type = %"std.array.Appender!(string[]).Appender"*]
  %.sroa.03.0..sroa_idx = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 3, i32 0 ; [#uses = 2, type = i64*]
  store i64 %s_arg.fca.0.extract, i64* %.sroa.03.0..sroa_idx, align 8
  %.sroa.2.0..sroa_idx4 = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 3, i32 1 ; [#uses = 2, type = i8**]
  store i8* %s_arg.fca.1.extract, i8** %.sroa.2.0..sroa_idx4, align 8
  %istart = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 4 ; [#uses = 2, type = i64*]
  store i64 0, i64* %istart, align 8
  store i8 0, i8* %inword, align 8
  %1 = tail call %"std.array.Appender!(string[]).Appender" @_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo() #2 ; [#uses = 1]
  %.fca.0.extract = extractvalue %"std.array.Appender!(string[]).Appender" %1, 0 ; [#uses = 1]
  %.sroa.0.0..sroa_idx = getelementptr inbounds %nest.split, %nest.split* %.frame, i64 0, i32 2, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  store %"std.array.Appender!(string[]).Appender.Data"* %.fca.0.extract, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8
  %2 = insertvalue { i8*, i32 (i8*, i8*, i8*)* } undef, i8* %inword, 0 ; [#uses = 1]
  %.func = insertvalue { i8*, i32 (i8*, i8*, i8*)* } %2, i32 (i8*, i8*, i8*)* bitcast (i32 (i8*, i32*, i64*)* @_D3std5array__T5splitTAyaZQlFNaNfQlZ14__foreachbody5MFNaNbNfKmKwZi to i32 (i8*, i8*, i8*)*), 1 ; [#uses = 1]
  %3 = call i32 @_aApplycd2({ i64, i8* } %s_arg, { i8*, i32 (i8*, i8*, i8*)* } %.func) #2 ; [#uses = 0]
  %4 = load i8, i8* %inword, align 8, !range !19  ; [#uses = 1]
  %.not = icmp eq i8 %4, 0                        ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %5 = load i64, i64* %istart, align 8            ; [#uses = 4]
  %.len = load i64, i64* %.sroa.03.0..sroa_idx, align 8 ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len, %5     ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %if
  %.ptr = load i8*, i8** %.sroa.2.0..sroa_idx4, align 8 ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %5 ; [#uses = 1, type = i8*]
  %6 = sub i64 %.len, %5                          ; [#uses = 1]
  %7 = insertvalue { i64, i8* } undef, i64 %6, 0  ; [#uses = 1]
  %8 = insertvalue { i64, i8* } %7, i8* %lowerbound, 1 ; [#uses = 1]
  call void @_D3std5range10primitives__T3putTSQBf5array__T8AppenderTAAyaZQpTQhZQBnFNaNbNfKQBtQyZv({ i64, i8* } %8, %"std.array.Appender!(string[]).Appender"* nonnull dereferenceable(8) %result) #2
  br label %endif

bounds.fail:                                      ; preds = %if
  call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 1831, i64 %5, i64 %.len, i64 %.len) #6
  unreachable

endif:                                            ; preds = %0, %bounds.ok
  %9 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %result, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %10 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %9, align 8 ; [#uses = 3]
  %.not.i.i = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %10, null ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya.exit, label %condtrue.i.i

condtrue.i.i:                                     ; preds = %endif
  %.fca.0.gep2.phi.trans.insert.i.i = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %10, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.fca.0.load.pre.i.i = load i64, i64* %.fca.0.gep2.phi.trans.insert.i.i, align 8 ; [#uses = 1]
  %.fca.1.gep3.phi.trans.insert.i.i = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %10, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.fca.1.load.pre.i.i = load { i64, i8* }*, { i64, i8* }** %.fca.1.gep3.phi.trans.insert.i.i, align 8 ; [#uses = 1]
  br label %_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya.exit

_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya.exit: ; preds = %endif, %condtrue.i.i
  %.fca.1.load.i.i = phi { i64, i8* }* [ %.fca.1.load.pre.i.i, %condtrue.i.i ], [ null, %endif ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load.i.i = phi i64 [ %.fca.0.load.pre.i.i, %condtrue.i.i ], [ 0, %endif ] ; [#uses = 1, type = i64]
  %.fca.0.insert.i.i = insertvalue { i64, { i64, i8* }* } undef, i64 %.fca.0.load.i.i, 0 ; [#uses = 1]
  %.fca.1.insert9.i.i = insertvalue { i64, { i64, i8* }* } %.fca.0.insert.i.i, { i64, i8* }* %.fca.1.load.i.i, 1 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %.fca.1.insert9.i.i
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5stdio__T6readlnTAyaZQmFwZQj(i32 %terminator_arg) local_unnamed_addr #0 {
  %1 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #2 ; [#uses = 1]
  %2 = tail call { i64, i8* } @_D3std5stdio4File__T6readlnTAyaZQmMFwZQk(%std.stdio.File* nonnull %1, i32 %terminator_arg) #2 ; [#uses = 1]
  ret { i64, i8* } %2
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* }* @_D3std5range10primitives__T5frontTAyaZQlFNaNbNcNdNiNfMNkANgAyaZNgQg({ i64, { i64, i8* }* } %a_arg) local_unnamed_addr #0 {
  %a_arg.fca.0.extract = extractvalue { i64, { i64, i8* }* } %a_arg, 0 ; [#uses = 1]
  %.not = icmp eq i64 %a_arg.fca.0.extract, 0     ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %a_arg.fca.1.extract = extractvalue { i64, { i64, i8* }* } %a_arg, 1 ; [#uses = 1]
  ret { i64, i8* }* %a_arg.fca.1.extract

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 57, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.8, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.9, i32 0, i32 0) }, i32 2472) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T8popFrontTAyaZQoFNaNbNiNfMKANgAyaZv({ i64, { i64, i8* }* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %a, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %2 = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %a, i64 0, i32 1 ; [#uses = 2, type = { i64, i8* }**]
  %.ptr = load { i64, i8* }*, { i64, i8* }** %2, align 8 ; [#uses = 1]
  %lowerbound = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr, i64 1 ; [#uses = 1, type = { i64, i8* }*]
  %3 = add i64 %.len, -1                          ; [#uses = 1]
  store i64 %3, i64* %1, align 8
  store { i64, i8* }* %lowerbound, { i64, i8* }** %2, align 8
  ret void

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 59, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.16, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.9, i32 0, i32 0) }, i32 2275) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std4conv__T2toTlZ__TQjTAyaZQqFNaNfQlZl({ i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  %1 = tail call i64 @_D3std4conv__T6toImplTlTAyaZQoFNaNfQlZl({ i64, i8* } %_param_0_arg) #2 ; [#uses = 1]
  ret i64 %1
}

; [#uses = 1]
declare %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5stdio4File__T6readlnTAyaZQmMFwZQk(%std.stdio.File* nonnull %.this_arg, i32 %terminator_arg) local_unnamed_addr #0 {
  %buf = alloca { i64, i8* }, align 8             ; [#uses = 4, size/byte = 16]
  %.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %buf, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %buf, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %1 = bitcast { i64, i8* }* %buf to i8*          ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %1, i8 0, i64 16, i1 false)
  %2 = call i64 @_D3std5stdio4File__T6readlnTaZQkMFKAawZm(%std.stdio.File* nonnull %.this_arg, i32 %terminator_arg, { i64, i8* }* nonnull dereferenceable(16) %buf) #2 ; [#uses = 0]
  %.len = load i64, i64* %.fca.0.gep, align 8     ; [#uses = 1]
  %.ptr = load i8*, i8** %.fca.1.gep, align 8     ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.ptr, 1  ; [#uses = 1]
  ret { i64, i8* } %4
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5stdio4File__T6readlnTaZQkMFKAawZm(%std.stdio.File* nonnull %.this_arg, i32 %terminator_arg, { i64, i8* }* dereferenceable(16) %buf) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %std.stdio.File, %std.stdio.File* %.this_arg, i64 0, i32 0 ; [#uses = 4, type = %std.stdio.File.Impl**]
  %2 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %1, align 8 ; [#uses = 3]
  %.not = icmp eq %std.stdio.File.Impl* %2, null  ; [#uses = 1]
  br i1 %.not, label %if.i, label %andandend

andandend:                                        ; preds = %0
  %3 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %2, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %4 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %3, align 8 ; [#uses = 2]
  %.not9 = icmp eq %core.stdc.stdio._IO_FILE* %4, null ; [#uses = 1]
  br i1 %.not9, label %if.i, label %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit

if.i:                                             ; preds = %andandend, %0
  tail call void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } { i64 38, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i32 0, i32 0) }, i64 2083, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i32 0, i32 0) }) #15
  unreachable

_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit: ; preds = %andandend
  %5 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %2, i64 0, i32 4 ; [#uses = 1, type = i32*]
  %6 = load i32, i32* %5, align 4                 ; [#uses = 1]
  %7 = icmp eq i32 %6, 0                          ; [#uses = 1]
  br i1 %7, label %if, label %endif

if:                                               ; preds = %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit
  %8 = tail call i32 @fwide(%core.stdc.stdio._IO_FILE* nonnull %4, i32 0) #2 ; [#uses = 2]
  %9 = icmp slt i32 %8, 0                         ; [#uses = 1]
  br i1 %9, label %if1, label %else

if1:                                              ; preds = %if
  %10 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %1, align 8 ; [#uses = 1]
  %11 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %10, i64 0, i32 4 ; [#uses = 1, type = i32*]
  store i32 1, i32* %11, align 4
  br label %endif

else:                                             ; preds = %if
  %.not7 = icmp eq i32 %8, 0                      ; [#uses = 1]
  br i1 %.not7, label %endif, label %if3

if3:                                              ; preds = %else
  %12 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %1, align 8 ; [#uses = 1]
  %13 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %12, i64 0, i32 4 ; [#uses = 1, type = i32*]
  store i32 2, i32* %13, align 4
  br label %endif

endif:                                            ; preds = %else, %if1, %if3, %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit
  %14 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %1, align 8 ; [#uses = 2]
  %15 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %14, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %16 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %15, align 8 ; [#uses = 1]
  %17 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %14, i64 0, i32 4 ; [#uses = 1, type = i32*]
  %18 = load i32, i32* %17, align 4               ; [#uses = 1]
  %19 = tail call i64 @_D3std5stdio10readlnImplFPOS4core4stdcQBg8_IO_FILEKAawEQCbQCa4File11OrientationZm(i32 %18, i32 %terminator_arg, { i64, i8* }* nonnull dereferenceable(16) %buf, %core.stdc.stdio._IO_FILE* %16) #2 ; [#uses = 1]
  ret i64 %19
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb(i64 %line_arg, { i64, i8* } %file_arg, { i8*, { i64, i8* } (i8*)* } %msg_arg, i1 zeroext %value_arg) local_unnamed_addr #0 {
  br i1 %value_arg, label %endif, label %if

if:                                               ; preds = %0
  %msg_arg.fca.1.extract = extractvalue { i8*, { i64, i8* } (i8*)* } %msg_arg, 1 ; [#uses = 1]
  %msg_arg.fca.0.extract = extractvalue { i8*, { i64, i8* } (i8*)* } %msg_arg, 0 ; [#uses = 1]
  %1 = tail call { i64, i8* } %msg_arg.fca.1.extract(i8* nonnull %msg_arg.fca.0.extract) ; [#uses = 1]
  tail call void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } %1, i64 %line_arg, { i64, i8* } %file_arg) #15
  unreachable

endif:                                            ; preds = %0
  ret i1 true
}

; [#uses = 1]
declare i32 @fwide(%core.stdc.stdio._IO_FILE*, i32) local_unnamed_addr #2

; [#uses = 1]
declare i64 @_D3std5stdio10readlnImplFPOS4core4stdcQBg8_IO_FILEKAawEQCbQCa4File11OrientationZm(i32, i32, { i64, i8* }* dereferenceable(16), %core.stdc.stdio._IO_FILE*) local_unnamed_addr #2

; [#uses = 4]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #3 {
  %.makelvaluetmp = alloca { i64, i8* }, align 8  ; [#uses = 2, size/byte = 16]
  %.makelvaluetmp2 = alloca { i64, i8* }, align 8 ; [#uses = 2, size/byte = 16]
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 1]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D9Exception7__ClassZ) #4 ; [#uses = 5]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D9Exception6__vtblZ, [10 x i8*]** %vtbl, align 8
  %1 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %1, align 8
  %2 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %3 = bitcast %object.Object* %2 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(60) %3, i8* nonnull align 8 dereferenceable(60) bitcast ({ i64, i8* }* getelementptr inbounds (%object.Exception, %object.Exception* @_D9Exception6__initZ, i64 0, i32 2) to i8*), i64 60, i1 false)
  %.not = icmp eq i8* %msg_arg.fca.1.extract, null ; [#uses = 1]
  br i1 %.not, label %condfalse, label %condtrue

condtrue:                                         ; preds = %0
  %4 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %msg_arg) #2 ; [#uses = 2]
  %.ptr1 = extractvalue { i64, i8* } %4, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %4, 0         ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.makelvaluetmp, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %5, align 8
  br label %condend

condfalse:                                        ; preds = %0
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.makelvaluetmp2, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 18, i64* %6, align 8
  br label %condend

condend:                                          ; preds = %condfalse, %condtrue
  %.makelvaluetmp2.sink = phi { i64, i8* }* [ %.makelvaluetmp2, %condfalse ], [ %.makelvaluetmp, %condtrue ] ; [#uses = 2, type = { i64, i8* }*]
  %.sink = phi i8* [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), %condfalse ], [ %.ptr1, %condtrue ] ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.makelvaluetmp2.sink, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.sink, i8** %7, align 8
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %object.Exception* ; [#uses = 1]
  %8 = tail call %object.Exception* @_D6object9Exception6__ctorMFNaNbNiNfAyaQdmCQBp9ThrowableZCQBx(%object.Exception* nonnull returned %.newclass_gc, %object.Throwable* null, i64 %line_arg, { i64, i8* } %file_arg, { i64, i8* }* nonnull byval align 8 %.makelvaluetmp2.sink) #2 ; [#uses = 0]
  %9 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %9) #6
  unreachable
}

; [#uses = 7]
; Function Attrs: uwtable
declare noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class*) local_unnamed_addr #4

; [#uses = 14]
; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #5

; [#uses = 1]
declare %object.Exception* @_D6object9Exception6__ctorMFNaNbNiNfAyaQdmCQBp9ThrowableZCQBx(%object.Exception* nonnull returned, %object.Throwable*, i64, { i64, i8* }, { i64, i8* }* byval align 8) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4idupTxaZQjFNaNbNdNfAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %1 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %a_arg) #2 ; [#uses = 1]
  ret { i64, i8* } %1
}

; [#uses = 37]
; Function Attrs: cold noreturn uwtable
declare void @_d_throw_exception(%object.Throwable*) local_unnamed_addr #6

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 2]
  %a_arg.fca.1.extract = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract) #2 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %1, 1         ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr, i8* align 1 %a_arg.fca.1.extract, i64 %a_arg.fca.0.extract, i1 false) #2
  ret { i64, i8* } %1
}

; [#uses = 1]
declare { i64, i8* } @_d_newarrayU(%object.TypeInfo*, i64) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T8_dupCtfeTxaTyaZQqFNaNbNfMAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %res = alloca { i64, i8* }, align 8             ; [#uses = 4, size/byte = 16]
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 1]
  %a_arg.fca.1.extract = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  %.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %res, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %res, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %1 = bitcast { i64, i8* }* %res to i8*          ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %1, i8 0, i64 16, i1 false)
  br label %forcond

forcond:                                          ; preds = %forbody, %0
  %__key181.0 = phi i64 [ 0, %0 ], [ %4, %forbody ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %__key181.0, %a_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %endfor, label %forbody

forbody:                                          ; preds = %forcond
  %2 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %__key181.0 ; [#uses = 1, type = i8*]
  %.appendedArray = call { i64, i8* } @_d_arrayappendcTX(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Aya6__initZ to %object.TypeInfo*), { i64, i8* }* nonnull dereferenceable(16) %res, i64 1) #4 ; [#uses = 0]
  %.len3 = load i64, i64* %.fca.0.gep, align 8    ; [#uses = 1]
  %.ptr4 = load i8*, i8** %.fca.1.gep, align 8    ; [#uses = 1]
  %.lastIndex = add i64 %.len3, -1                ; [#uses = 1]
  %.lastElem = getelementptr inbounds i8, i8* %.ptr4, i64 %.lastIndex ; [#uses = 1, type = i8*]
  %3 = load i8, i8* %2, align 1                   ; [#uses = 1]
  store i8 %3, i8* %.lastElem, align 1
  %4 = add i64 %__key181.0, 1                     ; [#uses = 1]
  br label %forcond

endfor:                                           ; preds = %forcond
  %.fca.0.load = load i64, i64* %.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.load = load i8*, i8** %.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert14 = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert14
}

; [#uses = 1]
; Function Attrs: uwtable
declare { i64, i8* } @_d_arrayappendcTX(%object.TypeInfo*, { i64, i8* }* dereferenceable(16), i64) local_unnamed_addr #4

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.array.Appender!(string[]).Appender" @_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo() local_unnamed_addr #0 {
  %.structliteral = alloca %"std.array.Appender!(string[]).Appender", align 8 ; [#uses = 2, size/byte = 8]
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.structliteral, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!(string[]).Appender.Data"**]
  store %"std.array.Appender!(string[]).Appender.Data"* null, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8
  %2 = call %"std.array.Appender!(string[]).Appender"* @_D3std5array__T8AppenderTAAyaZQp6__ctorMFNaNbNcNeQyZSQBzQBy__TQBvTQBpZQCd(%"std.array.Appender!(string[]).Appender"* nonnull returned %.structliteral, { i64, { i64, i8* }* } zeroinitializer) #2 ; [#uses = 0]
  %.fca.0.load = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %.fca.0.insert = insertvalue %"std.array.Appender!(string[]).Appender" undef, %"std.array.Appender!(string[]).Appender.Data"* %.fca.0.load, 0 ; [#uses = 1]
  ret %"std.array.Appender!(string[]).Appender" %.fca.0.insert
}

; [#uses = 1]
declare i32 @_aApplycd2({ i64, i8* }, { i8*, i32 (i8*, i8*, i8*)* }) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define linkonce_odr i32 @_D3std5array__T5splitTAyaZQlFNaNfQlZ14__foreachbody5MFNaNbNfKmKwZi(i8* nonnull %.nest_arg, i32* dereferenceable(4) %__applyArg1, i64* dereferenceable(8) %__applyArg0) #0 {
  %1 = load i32, i32* %__applyArg1, align 4       ; [#uses = 1]
  %2 = load i64, i64* %__applyArg0, align 8       ; [#uses = 5]
  %3 = tail call zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32 %1) #2 ; [#uses = 1]
  %4 = load i8, i8* %.nest_arg, align 1, !range !19 ; [#uses = 1]
  %.not = icmp eq i8 %4, 0                        ; [#uses = 2]
  br i1 %3, label %if, label %else

if:                                               ; preds = %0
  br i1 %.not, label %endif, label %if1

if1:                                              ; preds = %if
  %s = getelementptr inbounds i8, i8* %.nest_arg, i64 16 ; [#uses = 1, type = i8*]
  %istart = getelementptr inbounds i8, i8* %.nest_arg, i64 32 ; [#uses = 1, type = i8*]
  %5 = bitcast i8* %istart to i64*                ; [#uses = 1]
  %6 = load i64, i64* %5, align 8                 ; [#uses = 4]
  %7 = bitcast i8* %s to i64*                     ; [#uses = 1]
  %.len = load i64, i64* %7, align 8              ; [#uses = 2]
  %bounds.cmp.up = icmp ule i64 %2, %.len         ; [#uses = 1]
  %bounds.cmp.lo = icmp uge i64 %2, %6            ; [#uses = 1]
  %8 = and i1 %bounds.cmp.lo, %bounds.cmp.up      ; [#uses = 1]
  br i1 %8, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %if1
  %result = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %9 = bitcast i8* %result to %"std.array.Appender!(string[]).Appender"* ; [#uses = 1]
  %10 = getelementptr inbounds i8, i8* %.nest_arg, i64 24 ; [#uses = 1, type = i8*]
  %11 = bitcast i8* %10 to i8**                   ; [#uses = 1]
  %.ptr = load i8*, i8** %11, align 8             ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %6 ; [#uses = 1, type = i8*]
  %12 = sub i64 %2, %6                            ; [#uses = 1]
  %13 = insertvalue { i64, i8* } undef, i64 %12, 0 ; [#uses = 1]
  %14 = insertvalue { i64, i8* } %13, i8* %lowerbound, 1 ; [#uses = 1]
  tail call void @_D3std5range10primitives__T3putTSQBf5array__T8AppenderTAAyaZQpTQhZQBnFNaNbNfKQBtQyZv({ i64, i8* } %14, %"std.array.Appender!(string[]).Appender"* nonnull dereferenceable(8) %9) #2
  store i8 0, i8* %.nest_arg, align 1
  br label %endif

bounds.fail:                                      ; preds = %if1
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 1817, i64 %6, i64 %2, i64 %.len) #6
  unreachable

else:                                             ; preds = %0
  br i1 %.not, label %if5, label %endif

if5:                                              ; preds = %else
  %istart7 = getelementptr inbounds i8, i8* %.nest_arg, i64 32 ; [#uses = 1, type = i8*]
  %15 = bitcast i8* %istart7 to i64*              ; [#uses = 1]
  store i64 %2, i64* %15, align 8
  store i8 1, i8* %.nest_arg, align 1
  br label %endif

endif:                                            ; preds = %if, %else, %if5, %bounds.ok
  ret i32 0
}

; [#uses = 1]
declare zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32) local_unnamed_addr #2

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T3putTSQBf5array__T8AppenderTAAyaZQpTQhZQBnFNaNbNfKQBtQyZv({ i64, i8* } %e_arg, %"std.array.Appender!(string[]).Appender"* dereferenceable(8) %r) local_unnamed_addr #0 {
  %e = alloca { i64, i8* }, align 8               ; [#uses = 3, size/byte = 16]
  %e_arg.fca.0.extract = extractvalue { i64, i8* } %e_arg, 0 ; [#uses = 1]
  %e_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %e_arg.fca.0.extract, i64* %e_arg.fca.0.gep, align 8
  %e_arg.fca.1.extract = extractvalue { i64, i8* } %e_arg, 1 ; [#uses = 1]
  %e_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %e_arg.fca.1.extract, i8** %e_arg.fca.1.gep, align 8
  call void @_D3std5range10primitives__T5doPutTSQBh5array__T8AppenderTAAyaZQpTQhZQBpFNaNbNfKQBtKQzZv({ i64, i8* }* nonnull dereferenceable(16) %e, %"std.array.Appender!(string[]).Appender"* nonnull dereferenceable(8) %r) #2
  ret void
}

; [#uses = 7]
; Function Attrs: cold noreturn uwtable
declare void @_d_arraybounds_slice({ i64, i8* }, i32, i64, i64, i64) local_unnamed_addr #6

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not.i = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not.i, label %_D3std5array__T8AppenderTAAyaZQp7opSliceMNgFNaNbNdNiNeZANgAya.exit, label %condtrue.i

condtrue.i:                                       ; preds = %0
  %.fca.0.gep2.phi.trans.insert.i = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.fca.0.load.pre.i = load i64, i64* %.fca.0.gep2.phi.trans.insert.i, align 8 ; [#uses = 1]
  %.fca.1.gep3.phi.trans.insert.i = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.fca.1.load.pre.i = load { i64, i8* }*, { i64, i8* }** %.fca.1.gep3.phi.trans.insert.i, align 8 ; [#uses = 1]
  br label %_D3std5array__T8AppenderTAAyaZQp7opSliceMNgFNaNbNdNiNeZANgAya.exit

_D3std5array__T8AppenderTAAyaZQp7opSliceMNgFNaNbNdNiNeZANgAya.exit: ; preds = %0, %condtrue.i
  %.fca.1.load.i = phi { i64, i8* }* [ %.fca.1.load.pre.i, %condtrue.i ], [ null, %0 ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load.i = phi i64 [ %.fca.0.load.pre.i, %condtrue.i ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.fca.0.insert.i = insertvalue { i64, { i64, i8* }* } undef, i64 %.fca.0.load.i, 0 ; [#uses = 1]
  %.fca.1.insert9.i = insertvalue { i64, { i64, i8* }* } %.fca.0.insert.i, { i64, i8* }* %.fca.1.load.i, 1 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %.fca.1.insert9.i
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.array.Appender!(string[]).Appender"* @_D3std5array__T8AppenderTAAyaZQp6__ctorMFNaNbNcNeQyZSQBzQBy__TQBvTQBpZQCd(%"std.array.Appender!(string[]).Appender"* nonnull returned %.this_arg, { i64, { i64, i8* }* } %arr_arg) local_unnamed_addr #0 {
  %arr = alloca { i64, { i64, i8* }* }, align 8   ; [#uses = 3, size/byte = 16]
  %arr_arg.fca.0.extract = extractvalue { i64, { i64, i8* }* } %arr_arg, 0 ; [#uses = 4]
  %arr_arg.fca.0.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 0 ; [#uses = 2, type = i64*]
  store i64 %arr_arg.fca.0.extract, i64* %arr_arg.fca.0.gep, align 8
  %arr_arg.fca.1.extract = extractvalue { i64, { i64, i8* }* } %arr_arg, 1 ; [#uses = 2]
  %arr_arg.fca.1.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  store { i64, i8* }* %arr_arg.fca.1.extract, { i64, i8* }** %arr_arg.fca.1.gep, align 8
  %.gc_struct = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ to %object.TypeInfo*)) #4 ; [#uses = 4]
  %1 = getelementptr inbounds i8, i8* %.gc_struct, i64 8 ; [#uses = 1, type = i8*]
  %.repack = bitcast i8* %1 to i64*               ; [#uses = 1]
  %.repack5 = getelementptr inbounds i8, i8* %.gc_struct, i64 16 ; [#uses = 1, type = i8*]
  %2 = bitcast %"std.array.Appender!(string[]).Appender"* %.this_arg to i8** ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %.gc_struct, i8 0, i64 32, i1 false)
  store i8* %.gc_struct, i8** %2, align 8
  %3 = ptrtoint { i64, i8* }* %arr_arg.fca.1.extract to i64 ; [#uses = 1]
  store i64 %arr_arg.fca.0.extract, i64* %.repack, align 8
  %4 = bitcast i8* %.repack5 to i64*              ; [#uses = 1]
  store i64 %3, i64* %4, align 8
  %5 = tail call i64 @_D6object__T8capacityTAyaZQoFNaNbNdNeAQqZm({ i64, { i64, i8* }* } %arr_arg) #2 ; [#uses = 2]
  %6 = icmp ugt i64 %5, %arr_arg.fca.0.extract    ; [#uses = 1]
  br i1 %6, label %if, label %endif

if:                                               ; preds = %0
  %7 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %5, { i64, { i64, i8* }* }* nonnull dereferenceable(16) %arr) #16 ; [#uses = 0]
  %.len3.pre = load i64, i64* %arr_arg.fca.0.gep, align 8 ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %if, %0
  %.len3 = phi i64 [ %.len3.pre, %if ], [ %arr_arg.fca.0.extract, %0 ] ; [#uses = 1, type = i64]
  %8 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %9 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %8, align 8 ; [#uses = 1]
  %10 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %9, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len3, i64* %10, align 8
  ret %"std.array.Appender!(string[]).Appender"* %.this_arg
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5array__T8AppenderTAAyaZQp4Data11__xopEqualsFKxSQCaQBz__TQBwTQBqZQCeQBqKxQBaZb(%"std.array.Appender!(string[]).Appender.Data"* dereferenceable(32) %q, %"std.array.Appender!(string[]).Appender.Data"* dereferenceable(32) %p) #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %q, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %3 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %4 = load i64, i64* %2, align 8                 ; [#uses = 1]
  %5 = icmp eq i64 %3, %4                         ; [#uses = 1]
  br i1 %5, label %andand, label %andandend2

andand:                                           ; preds = %0
  %.elt = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %6 = insertvalue { i64, { i64, i8* }* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt4 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.unpack5 = load { i64, i8* }*, { i64, i8* }** %.elt4, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, { i64, i8* }* } %6, { i64, i8* }* %.unpack5, 1 ; [#uses = 1]
  %.elt6 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %q, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack7 = load i64, i64* %.elt6, align 8      ; [#uses = 1]
  %8 = insertvalue { i64, { i64, i8* }* } undef, i64 %.unpack7, 0 ; [#uses = 1]
  %.elt8 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %q, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.unpack9 = load { i64, i8* }*, { i64, i8* }** %.elt8, align 8 ; [#uses = 1]
  %9 = insertvalue { i64, { i64, i8* }* } %8, { i64, i8* }* %.unpack9, 1 ; [#uses = 1]
  %10 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTxAyaTxQfZQtFNaNbNiNfMAxQwMQfZb({ i64, { i64, i8* }* } %9, { i64, { i64, i8* }* } %7) #2 ; [#uses = 1]
  br i1 %10, label %andand1, label %andandend2

andand1:                                          ; preds = %andand
  %11 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %12 = load i8, i8* %11, align 1, !range !19     ; [#uses = 1]
  %13 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %q, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %14 = load i8, i8* %13, align 1, !range !19     ; [#uses = 1]
  %15 = icmp eq i8 %12, %14                       ; [#uses = 1]
  br label %andandend2

andandend2:                                       ; preds = %0, %andand1, %andand
  %andandval3 = phi i1 [ false, %andand ], [ %15, %andand1 ], [ false, %0 ] ; [#uses = 1, type = i1]
  ret i1 %andandval3
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D4core8internal5array8equality__T8__equalsTxAyaTxQfZQtFNaNbNiNfMAxQwMQfZb({ i64, { i64, i8* }* } %rhs_arg, { i64, { i64, i8* }* } %lhs_arg) local_unnamed_addr #0 {
  %lhs_arg.fca.0.extract = extractvalue { i64, { i64, i8* }* } %lhs_arg, 0 ; [#uses = 3]
  %rhs_arg.fca.0.extract = extractvalue { i64, { i64, i8* }* } %rhs_arg, 0 ; [#uses = 1]
  %.not = icmp eq i64 %lhs_arg.fca.0.extract, %rhs_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %forbody, %forcond, %0, %endif
  %merge = phi i1 [ false, %0 ], [ true, %endif ], [ true, %forcond ], [ false, %forbody ] ; [#uses = 1, type = i1]
  ret i1 %merge

endif:                                            ; preds = %0
  %1 = icmp eq i64 %lhs_arg.fca.0.extract, 0      ; [#uses = 1]
  br i1 %1, label %if, label %forcond.preheader

forcond.preheader:                                ; preds = %endif
  %r_arg.fca.1.extract.i = extractvalue { i64, { i64, i8* }* } %lhs_arg, 1 ; [#uses = 2]
  %r_arg.fca.1.extract.i26 = extractvalue { i64, { i64, i8* }* } %rhs_arg, 1 ; [#uses = 2]
  br label %forcond

forcond:                                          ; preds = %forbody, %forcond.preheader
  %__key203.0 = phi i64 [ %7, %forbody ], [ 0, %forcond.preheader ] ; [#uses = 6, type = i64]
  %exitcond.not = icmp eq i64 %__key203.0, %lhs_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %forbody

forbody:                                          ; preds = %forcond
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i, i64 %__key203.0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %2 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i, i64 %__key203.0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack21 = load i8*, i8** %.elt20, align 8    ; [#uses = 1]
  %3 = insertvalue { i64, i8* } %2, i8* %.unpack21, 1 ; [#uses = 1]
  %.elt22 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i26, i64 %__key203.0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack23 = load i64, i64* %.elt22, align 8    ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %.unpack23, 0 ; [#uses = 1]
  %.elt24 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i26, i64 %__key203.0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack25 = load i8*, i8** %.elt24, align 8    ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %.unpack25, 1 ; [#uses = 1]
  %6 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %5, { i64, i8* } %3) #0 ; [#uses = 1]
  %7 = add i64 %__key203.0, 1                     ; [#uses = 1]
  br i1 %6, label %forcond, label %if
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T8AppenderTAAyaZQp4Data9__xtoHashFNbNeKxSQCbQCa__TQBxTQBrZQCfQBrZm(%"std.array.Appender!(string[]).Appender.Data"* dereferenceable(32) %p) #0 {
unrolledstmt:
  %0 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D11TypeInfo_xm6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl" = getelementptr inbounds [19 x i8*], [19 x i8*]* %0, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %1 = bitcast i8** %"getHash@vtbl" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %2 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %1, align 8 ; [#uses = 1]
  %3 = bitcast %"std.array.Appender!(string[]).Appender.Data"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D11TypeInfo_xm6__initZ, i8* nonnull %3) ; [#uses = 1]
  %5 = mul i64 %4, 33                             ; [#uses = 1]
  %6 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D14TypeInfo_xAAya6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl3" = getelementptr inbounds [19 x i8*], [19 x i8*]* %6, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %7 = bitcast i8** %"getHash@vtbl3" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %8 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %7, align 8 ; [#uses = 1]
  %9 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 1 ; [#uses = 1, type = { i64, { i64, i8* }* }*]
  %10 = bitcast { i64, { i64, i8* }* }* %9 to i8* ; [#uses = 1]
  %11 = tail call i64 %8(%object.TypeInfo_Const* nonnull @_D14TypeInfo_xAAya6__initZ, i8* nonnull %10) ; [#uses = 1]
  %12 = add i64 %11, %5                           ; [#uses = 1]
  %13 = mul i64 %12, 33                           ; [#uses = 1]
  %14 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D11TypeInfo_xb6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl5" = getelementptr inbounds [19 x i8*], [19 x i8*]* %14, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %15 = bitcast i8** %"getHash@vtbl5" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %16 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %15, align 8 ; [#uses = 1]
  %17 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %p, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %18 = tail call i64 %16(%object.TypeInfo_Const* nonnull @_D11TypeInfo_xb6__initZ, i8* nonnull %17) ; [#uses = 1]
  %19 = add i64 %18, %13                          ; [#uses = 1]
  ret i64 %19
}

; [#uses = 4]
; Function Attrs: uwtable
declare noalias i8* @_d_newitemT(%object.TypeInfo*) local_unnamed_addr #4

; [#uses = 8]
; Function Attrs: argmemonly nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #7

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D6object__T8capacityTAyaZQoFNaNbNdNeAQqZm({ i64, { i64, i8* }* } %arr_arg) local_unnamed_addr #0 {
  %arr = alloca { i64, { i64, i8* }* }, align 8   ; [#uses = 3, size/byte = 16]
  %arr_arg.fca.0.extract = extractvalue { i64, { i64, i8* }* } %arr_arg, 0 ; [#uses = 1]
  %arr_arg.fca.0.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %arr_arg.fca.0.extract, i64* %arr_arg.fca.0.gep, align 8
  %arr_arg.fca.1.extract = extractvalue { i64, { i64, i8* }* } %arr_arg, 1 ; [#uses = 1]
  %arr_arg.fca.1.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  store { i64, i8* }* %arr_arg.fca.1.extract, { i64, i8* }** %arr_arg.fca.1.gep, align 8
  %1 = bitcast { i64, { i64, i8* }* }* %arr to { i64, i8* }* ; [#uses = 1]
  %2 = call i64 @_d_arraysetcapacity(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), i64 0, { i64, i8* }* nonnull %1) #2 ; [#uses = 1]
  ret i64 %2
}

; [#uses = 2]
; Function Attrs: noinline uwtable
define weak_odr i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %newlength_arg, { i64, { i64, i8* }* }* dereferenceable(16) %arr) local_unnamed_addr #8 {
  %1 = bitcast { i64, { i64, i8* }* }* %arr to { i64, i8* }* ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_arraysetlengthT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), i64 %newlength_arg, { i64, i8* }* nonnull %1) #2 ; [#uses = 0]
  %3 = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  ret i64 %.len
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp7reserveMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 %newCapacity_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %endif.sink.split, label %if

if:                                               ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = icmp ult i64 %4, %newCapacity_arg          ; [#uses = 1]
  br i1 %5, label %if1, label %endif

if1:                                              ; preds = %if
  %6 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %6, align 8              ; [#uses = 1]
  %7 = sub i64 %newCapacity_arg, %.len            ; [#uses = 1]
  br label %endif.sink.split

endif.sink.split:                                 ; preds = %0, %if1
  %.sink = phi i64 [ %7, %if1 ], [ %newCapacity_arg, %0 ] ; [#uses = 1, type = i64]
  tail call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 %.sink) #2
  br label %endif

endif:                                            ; preds = %endif.sink.split, %if
  ret void
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 %nelems_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.ensureAddable, align 8   ; [#uses = 10, size/byte = 64]
  %.sret_tmp = alloca %core.memory.BlkInfo_, align 8 ; [#uses = 2, size/byte = 24]
  %this = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!(string[]).Appender"**]
  store %"std.array.Appender!(string[]).Appender"* %.this_arg, %"std.array.Appender!(string[]).Appender"** %this, align 8
  %nelems = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 1 ; [#uses = 1, type = i64*]
  store i64 %nelems_arg, i64* %nelems, align 8
  %newlen = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 2 ; [#uses = 2, type = i64*]
  %len = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 3 ; [#uses = 3, type = i64*]
  %nbytes = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 4 ; [#uses = 1, type = i64*]
  %bi = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 5 ; [#uses = 2, type = %core.memory.BlkInfo_*]
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 6, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %if, label %endif

if:                                               ; preds = %0
  %.gc_struct = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ to %object.TypeInfo*)) #4 ; [#uses = 3]
  %3 = bitcast %"std.array.Appender!(string[]).Appender"* %.this_arg to i8** ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %.gc_struct, i8 0, i64 32, i1 false)
  store i8* %.gc_struct, i8** %3, align 8
  %4 = bitcast i8* %.gc_struct to %"std.array.Appender!(string[]).Appender.Data"* ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %if, %0
  %5 = phi %"std.array.Appender!(string[]).Appender.Data"* [ %4, %if ], [ %2, %0 ] ; [#uses = 2, type = %"std.array.Appender!(string[]).Appender.Data"*]
  %6 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %5, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %6, align 8              ; [#uses = 2]
  store i64 %.len, i64* %len, align 8
  %7 = add i64 %.len, %nelems_arg                 ; [#uses = 2]
  %8 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %5, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %9 = load i64, i64* %8, align 8                 ; [#uses = 2]
  %.not30 = icmp ult i64 %9, %7                   ; [#uses = 1]
  br i1 %.not30, label %endif4, label %if3

if3:                                              ; preds = %endif
  ret void

endif4:                                           ; preds = %endif
  %10 = tail call i64 @_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm(i64 %7, i64 %9) #2 ; [#uses = 2]
  store i64 %10, i64* %newlen, align 8
  %11 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %12 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %11, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %12, align 1, !range !19     ; [#uses = 1]
  %.not31 = icmp eq i8 %13, 0                     ; [#uses = 1]
  br i1 %.not31, label %endif6, label %if5

if5:                                              ; preds = %endif4
  %14 = bitcast %nest.ensureAddable* %.frame to i8* ; [#uses = 1]
  %15 = call i64 @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFmZ9__lambda5MFNaNbNeZm(i8* nonnull %14) ; [#uses = 2]
  %.not34 = icmp eq i64 %15, 0                    ; [#uses = 1]
  br i1 %.not34, label %if5.endif6_crit_edge, label %if7

if5.endif6_crit_edge:                             ; preds = %if5
  %.pre = load i64, i64* %newlen, align 8         ; [#uses = 1]
  br label %endif6

if7:                                              ; preds = %if5
  %16 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %17 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %16, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %18 = lshr i64 %15, 4                           ; [#uses = 1]
  store i64 %18, i64* %17, align 8
  ret void

endif6:                                           ; preds = %if5.endif6_crit_edge, %endif4
  %19 = phi i64 [ %.pre, %if5.endif6_crit_edge ], [ %10, %endif4 ] ; [#uses = 1, type = i64]
  %20 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %19, i64 16) #10 ; [#uses = 2]
  %21 = extractvalue { i64, i1 } %20, 0           ; [#uses = 1]
  %22 = extractvalue { i64, i1 } %20, 1           ; [#uses = 1]
  store i64 %21, i64* %nbytes, align 8
  br i1 %22, label %assertFailed, label %endif11

assertFailed:                                     ; preds = %endif6
  call void @_d_assert_msg({ i64, i8* } { i64 57, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.5, i32 0, i32 0) }, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 3452) #6
  unreachable

endif11:                                          ; preds = %endif6
  %23 = bitcast %nest.ensureAddable* %.frame to i8* ; [#uses = 1]
  call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFmZ9__lambda9MFNaNbNeZS4core6memory8BlkInfo_(%core.memory.BlkInfo_* noalias nonnull sret align 8 %.sret_tmp, i8* nonnull %23)
  %24 = bitcast %core.memory.BlkInfo_* %bi to i8* ; [#uses = 1]
  %25 = bitcast %core.memory.BlkInfo_* %.sret_tmp to i8* ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(24) %24, i8* nonnull align 8 dereferenceable(24) %25, i64 24, i1 false)
  %26 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %27 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %26, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %28 = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 5, i32 1 ; [#uses = 1, type = i64*]
  %29 = load i64, i64* %28, align 8               ; [#uses = 1]
  %30 = lshr i64 %29, 4                           ; [#uses = 1]
  store i64 %30, i64* %27, align 8
  %31 = load i64, i64* %len, align 8              ; [#uses = 2]
  %.not33 = icmp eq i64 %31, 0                    ; [#uses = 1]
  br i1 %.not33, label %endif16, label %if15

if15:                                             ; preds = %endif11
  %32 = getelementptr inbounds %nest.ensureAddable, %nest.ensureAddable* %.frame, i64 0, i32 5, i32 0 ; [#uses = 1, type = i8**]
  %33 = load i8*, i8** %32, align 8               ; [#uses = 1]
  %34 = load %"std.array.Appender!(string[]).Appender"*, %"std.array.Appender!(string[]).Appender"** %this, align 8 ; [#uses = 1]
  %35 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %34, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %36 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %35, align 8 ; [#uses = 1]
  %37 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %36, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %38 = bitcast { i64, i8* }** %37 to i8**        ; [#uses = 1]
  %.ptr1.i = load i8*, i8** %38, align 8          ; [#uses = 1]
  %39 = shl i64 %31, 4                            ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %33, i8* align 1 %.ptr1.i, i64 %39, i1 false) #2
  %.pre39 = load i64, i64* %len, align 8          ; [#uses = 1]
  br label %endif16

endif16:                                          ; preds = %endif11, %if15
  %40 = phi i64 [ 0, %endif11 ], [ %.pre39, %if15 ] ; [#uses = 1, type = i64]
  %41 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %42 = bitcast %core.memory.BlkInfo_* %bi to i64* ; [#uses = 1]
  %43 = load i64, i64* %42, align 8               ; [#uses = 1]
  %44 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %41, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %40, i64* %44, align 8
  %45 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %41, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %46 = bitcast { i64, i8* }** %45 to i64*        ; [#uses = 1]
  store i64 %43, i64* %46, align 8
  %47 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %48 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %47, i64 0, i32 2 ; [#uses = 1, type = i8*]
  store i8 1, i8* %48, align 1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T8AppenderTAAyaZQp8capacityMxFNaNbNdNiNfZm(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %condend, label %condtrue

condtrue:                                         ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %condtmp.0.sroa.speculate.load.condtrue = load i64, i64* %3, align 8 ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %condtmp.0.sroa.speculated = phi i64 [ %condtmp.0.sroa.speculate.load.condtrue, %condtrue ], [ 0, %0 ] ; [#uses = 1, type = i64]
  ret i64 %condtmp.0.sroa.speculated
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__T8AppenderTAAyaZQp7opSliceMNgFNaNbNdNiNeZANgAya(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %condend, label %condtrue

condtrue:                                         ; preds = %0
  %.fca.0.gep2.phi.trans.insert = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.fca.0.load.pre = load i64, i64* %.fca.0.gep2.phi.trans.insert, align 8 ; [#uses = 1]
  %.fca.1.gep3.phi.trans.insert = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.fca.1.load.pre = load { i64, i8* }*, { i64, i8* }** %.fca.1.gep3.phi.trans.insert, align 8 ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %.fca.1.load = phi { i64, i8* }* [ %.fca.1.load.pre, %condtrue ], [ null, %0 ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %condtrue ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, { i64, i8* }* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert9 = insertvalue { i64, { i64, i8* }* } %.fca.0.insert, { i64, i8* }* %.fca.1.load, 1 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %.fca.1.insert9
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm(i64 %reqLen_arg, i64 %curLen_arg) local_unnamed_addr #0 {
  %1 = icmp eq i64 %curLen_arg, 0                 ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %0
  %2 = icmp ugt i64 %reqLen_arg, 8                ; [#uses = 1]
  %spec.select.i = select i1 %2, i64 %reqLen_arg, i64 8 ; [#uses = 1]
  ret i64 %spec.select.i

endif:                                            ; preds = %0
  %3 = shl i64 %curLen_arg, 4                     ; [#uses = 1]
  %4 = tail call i64 @llvm.ctlz.i64(i64 %3, i1 immarg true) #10, !range !20 ; [#uses = 1]
  %5 = trunc i64 %4 to i16                        ; [#uses = 1]
  %.rhs.trunc = sub nuw nsw i16 64, %5            ; [#uses = 1]
  %6 = udiv i16 1000, %.rhs.trunc                 ; [#uses = 1]
  %.zext = zext i16 %6 to i64                     ; [#uses = 2]
  %7 = icmp ult i64 %.zext, 100                   ; [#uses = 1]
  %8 = select i1 %7, i64 %.zext, i64 100          ; [#uses = 1]
  %spec.store.select = add nuw nsw i64 %8, 100    ; [#uses = 1]
  %9 = mul i64 %spec.store.select, %curLen_arg    ; [#uses = 1]
  %10 = add i64 %9, 99                            ; [#uses = 1]
  %11 = udiv i64 %10, 100                         ; [#uses = 2]
  %12 = icmp ugt i64 %11, %reqLen_arg             ; [#uses = 1]
  %b_arg.a_arg.i = select i1 %12, i64 %11, i64 %reqLen_arg ; [#uses = 1]
  ret i64 %b_arg.a_arg.i
}

; [#uses = 1]
; Function Attrs: uwtable
define linkonce_odr i64 @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFmZ9__lambda5MFNaNbNeZm(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %this = bitcast i8* %.nest_arg to %"std.array.Appender!(string[]).Appender"** ; [#uses = 1]
  %1 = load %"std.array.Appender!(string[]).Appender"*, %"std.array.Appender!(string[]).Appender"** %this, align 8 ; [#uses = 1]
  %2 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %1, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %3 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %2, align 8 ; [#uses = 1]
  %4 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %3, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %5 = bitcast { i64, i8* }** %4 to i8**          ; [#uses = 1]
  %.ptr1 = load i8*, i8** %5, align 8             ; [#uses = 1]
  %nelems = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %6 = bitcast i8* %nelems to i64*                ; [#uses = 1]
  %7 = load i64, i64* %6, align 8                 ; [#uses = 1]
  %8 = shl i64 %7, 4                              ; [#uses = 1]
  %newlen = getelementptr inbounds i8, i8* %.nest_arg, i64 16 ; [#uses = 1, type = i8*]
  %9 = bitcast i8* %newlen to i64*                ; [#uses = 1]
  %10 = load i64, i64* %9, align 8                ; [#uses = 1]
  %len = getelementptr inbounds i8, i8* %.nest_arg, i64 24 ; [#uses = 1, type = i8*]
  %11 = bitcast i8* %len to i64*                  ; [#uses = 1]
  %12 = load i64, i64* %11, align 8               ; [#uses = 1]
  %13 = sub i64 %10, %12                          ; [#uses = 1]
  %14 = shl i64 %13, 4                            ; [#uses = 1]
  %15 = tail call i64 @gc_extend(i8* %.ptr1, i64 %8, i64 %14, %object.TypeInfo* null) #2 ; [#uses = 1]
  ret i64 %15
}

; [#uses = 2]
declare i64 @gc_extend(i8*, i64, i64, %object.TypeInfo*) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: alwaysinline uwtable
define weak_odr i64 @_D4core10checkedint__T4muluZQgFNaNbNiNfmmKbZm(i8* dereferenceable(1) %overflow, i64 %y_arg, i64 %x_arg) local_unnamed_addr #9 {
  %1 = tail call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %x_arg, i64 %y_arg) #10 ; [#uses = 2]
  %2 = extractvalue { i64, i1 } %1, 0             ; [#uses = 1]
  %3 = extractvalue { i64, i1 } %1, 1             ; [#uses = 1]
  %4 = zext i1 %3 to i8                           ; [#uses = 1]
  %5 = load i8, i8* %overflow, align 1, !range !19 ; [#uses = 1]
  %6 = or i8 %5, %4                               ; [#uses = 1]
  store i8 %6, i8* %overflow, align 1
  ret i64 %2
}

; [#uses = 2]
; Function Attrs: nounwind readnone speculatable willreturn
declare { i64, i1 } @llvm.umul.with.overflow.i64(i64, i64) #10

; [#uses = 7]
; Function Attrs: cold noreturn uwtable
declare void @_d_assert_msg({ i64, i8* }, { i64, i8* }, i32) local_unnamed_addr #6

; [#uses = 1]
; Function Attrs: uwtable
define linkonce_odr void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFmZ9__lambda9MFNaNbNeZS4core6memory8BlkInfo_(%core.memory.BlkInfo_* noalias sret align 8 %.sret_arg, i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %nbytes = getelementptr inbounds i8, i8* %.nest_arg, i64 32 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %nbytes to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  tail call void @gc_qalloc(%core.memory.BlkInfo_* noalias sret align 8 %.sret_arg, i64 %2, i32 0, %object.TypeInfo* null) #2
  ret void
}

; [#uses = 2]
declare void @gc_qalloc(%core.memory.BlkInfo_* noalias sret align 8, i64, i32, %object.TypeInfo*) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp5clearMFNaNbNiNeZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 0, i64* %3, align 8
  br label %endif

endif:                                            ; preds = %0, %if
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp8shrinkToMFNaNemZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 %newlength_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %else, label %if

if:                                               ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  %.not6 = icmp ult i64 %.len, %newlength_arg     ; [#uses = 1]
  br i1 %.not6, label %if.i, label %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit

if.i:                                             ; preds = %if
  tail call void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } { i64 53, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i32 0, i32 0) }, i64 3644, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }) #15
  unreachable

_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit: ; preds = %if
  store i64 %newlength_arg, i64* %3, align 8
  br label %endif

else:                                             ; preds = %0
  %4 = icmp eq i64 %newlength_arg, 0              ; [#uses = 1]
  br i1 %4, label %endif, label %if.i4

if.i4:                                            ; preds = %else
  tail call void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } { i64 59, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.7, i32 0, i32 0) }, i64 3648, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }) #15
  unreachable

endif:                                            ; preds = %else, %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit
  ret void
}

; [#uses = 10]
; Function Attrs: cold noreturn uwtable
declare void @_d_arraybounds_index({ i64, i8* }, i32, i64, i64) local_unnamed_addr #6

; [#uses = 1]
declare { i64, i8* } @_d_arraysetlengthT(%object.TypeInfo*, i64, { i64, i8* }*) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: noinline uwtable
define weak_odr i64 @_D4core8internal5array5utils__T16_d_HookTraceImplTAAyaS_DQCdQCbQBv8capacity__T22_d_arraysetlengthTImplHTQCcTQCfZ18_d_arraysetlengthTFNaNbNeMNkKQDpmZmVQDva79_43616e6e6f7420726573697a652061727261797320696620636f6d70696c696e6720776974686f757420737570706f727420666f722072756e74696d65207479706520696e666f726d6174696f6e21ZQKzFNaNbNeQKpiQKtMNkKQLbmZm(i64 %_param_4_arg, { i64, { i64, i8* }* }* dereferenceable(16) %_param_3, { i64, i8* } %funcname_arg, i32 %line_arg, { i64, i8* }* byval align 8 %file) local_unnamed_addr #8 {
finally:
  %.sret_tmp = alloca %core.memory.GC.Stats, align 8 ; [#uses = 2, size/byte = 24]
  %.sret_tmp1 = alloca %core.memory.GC.Stats, align 8 ; [#uses = 2, size/byte = 24]
  call void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias nonnull sret align 8 %.sret_tmp) #2
  %0 = getelementptr inbounds %core.memory.GC.Stats, %core.memory.GC.Stats* %.sret_tmp, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %1 = load i64, i64* %0, align 8                 ; [#uses = 1]
  %2 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %_param_4_arg, { i64, { i64, i8* }* }* nonnull dereferenceable(16) %_param_3) #8 ; [#uses = 1]
  call void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias nonnull sret align 8 %.sret_tmp1) #2
  %3 = getelementptr inbounds %core.memory.GC.Stats, %core.memory.GC.Stats* %.sret_tmp1, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = sub i64 %4, %1                             ; [#uses = 2]
  %.not = icmp eq i64 %5, 0                       ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %finally
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %file, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %file, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack8 = load i8*, i8** %.elt7, align 8      ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack8, 1 ; [#uses = 1]
  %8 = call i64 @_D4core8internal5array5utils14accumulatePureFNaNbAyaiQeQgmZm(i64 %5, { i64, i8* } { i64 8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0) }, { i64, i8* } %funcname_arg, i32 %line_arg, { i64, i8* } %7) #2 ; [#uses = 1]
  %.not9 = icmp eq i64 %8, 0                      ; [#uses = 1]
  br i1 %.not9, label %assertFailed, label %endif

assertFailed:                                     ; preds = %if
  call void @_d_assert({ i64, i8* } { i64 67, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i32 0, i32 0) }, i32 86) #6
  unreachable

endif:                                            ; preds = %finally, %if
  ret i64 %2
}

; [#uses = 4]
declare void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias sret align 8) local_unnamed_addr #2

; [#uses = 2]
declare i64 @_D4core8internal5array5utils14accumulatePureFNaNbAyaiQeQgmZm(i64, { i64, i8* }, { i64, i8* }, i32, { i64, i8* }) local_unnamed_addr #2

; [#uses = 12]
; Function Attrs: cold noreturn uwtable
declare void @_d_assert({ i64, i8* }, i32) local_unnamed_addr #6

; [#uses = 1]
declare i64 @_d_arraysetcapacity(%object.TypeInfo*, i64, { i64, i8* }*) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T5doPutTSQBh5array__T8AppenderTAAyaZQpTQhZQBpFNaNbNfKQBtKQzZv({ i64, i8* }* dereferenceable(16) %e, %"std.array.Appender!(string[]).Appender"* dereferenceable(8) %r) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  tail call void @_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv(%"std.array.Appender!(string[]).Appender"* nonnull %r, { i64, i8* } %2) #2
  ret void
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, { i64, i8* } %item_arg) local_unnamed_addr #0 {
  tail call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 1) #0
  %1 = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %2 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %3 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 5]
  %4 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.ptr.i = load { i64, i8* }*, { i64, i8* }** %4, align 8 ; [#uses = 4]
  %5 = add i64 %.len, 1                           ; [#uses = 2]
  %bounds.cmp.not = icmp eq i64 %.len, -1         ; [#uses = 1]
  br i1 %bounds.cmp.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %item_arg.fca.1.extract = extractvalue { i64, i8* } %item_arg, 1 ; [#uses = 1]
  %6 = ptrtoint i8* %item_arg.fca.1.extract to i64 ; [#uses = 1]
  %item_arg.fca.0.extract = extractvalue { i64, i8* } %item_arg, 0 ; [#uses = 1]
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i, i64 %.len, i32 1 ; [#uses = 1, type = i8**]
  %8 = bitcast i8** %7 to i64*                    ; [#uses = 1]
  store i64 0, i64* %8, align 1
  %9 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i, i64 %.len, i32 0 ; [#uses = 1, type = i64*]
  store i64 %item_arg.fca.0.extract, i64* %9, align 8
  %10 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i, i64 %.len, i32 1 ; [#uses = 1, type = i8**]
  %11 = bitcast i8** %10 to i64*                  ; [#uses = 1]
  store i64 %6, i64* %11, align 8
  %12 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %13 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %12, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %5, i64* %13, align 8
  %14 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %12, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  store { i64, i8* }* %.ptr.i, { i64, i8* }** %14, align 8
  ret void

bounds.fail:                                      ; preds = %0
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 3515, i64 -1, i64 %5) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAyaZQlFNaNbNdNiNfMKQtZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  ret i1 %.not
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std5range10primitives__T5frontTaZQjFNaNdNfMAxaZw({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %a = alloca { i64, i8* }, align 8               ; [#uses = 3, size/byte = 16]
  %i = alloca i64, align 8                        ; [#uses = 2, size/byte = 8]
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 2]
  %a_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %a_arg.fca.0.extract, i64* %a_arg.fca.0.gep, align 8
  %a_arg.fca.1.extract = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  %a_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %a_arg.fca.1.extract, i8** %a_arg.fca.1.gep, align 8
  %.not = icmp eq i64 %a_arg.fca.0.extract, 0     ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %0
  store i64 0, i64* %i, align 8
  %1 = call i32 @_D3std3utf__T6decodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDhFNaNeKQnKmZw(i64* nonnull dereferenceable(8) %i, { i64, i8* }* nonnull dereferenceable(16) %a) #2 ; [#uses = 1]
  ret i32 %1

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 55, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.12, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.9, i32 0, i32 0) }, i32 2502) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T6decodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDhFNaNeKQnKmZw(i64* dereferenceable(8) %index, { i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %2 = load i64, i64* %index, align 8             ; [#uses = 6]
  %3 = icmp ult i64 %2, %.len                     ; [#uses = 1]
  br i1 %3, label %bounds.ok, label %assertFailed

bounds.ok:                                        ; preds = %0
  %4 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %.ptr = load i8*, i8** %4, align 8              ; [#uses = 1]
  %5 = getelementptr inbounds i8, i8* %.ptr, i64 %2 ; [#uses = 1, type = i8*]
  %6 = load i8, i8* %5, align 1                   ; [#uses = 1]
  %7 = icmp sgt i8 %6, -1                         ; [#uses = 1]
  br i1 %7, label %if, label %else

if:                                               ; preds = %bounds.ok
  %8 = add nuw i64 %2, 1                          ; [#uses = 1]
  store i64 %8, i64* %index, align 8
  %.len2 = load i64, i64* %1, align 8             ; [#uses = 2]
  %bounds.cmp3 = icmp ult i64 %2, %.len2          ; [#uses = 1]
  br i1 %bounds.cmp3, label %bounds.ok4, label %bounds.fail5

bounds.ok4:                                       ; preds = %if
  %.ptr6 = load i8*, i8** %4, align 8             ; [#uses = 1]
  %9 = getelementptr inbounds i8, i8* %.ptr6, i64 %2 ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  %11 = zext i8 %10 to i32                        ; [#uses = 1]
  br label %label.__returnLabel

bounds.fail5:                                     ; preds = %if
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1184, i64 %2, i64 %.len2) #6
  unreachable

else:                                             ; preds = %bounds.ok
  %12 = tail call i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFNaKQlKmZw(i64* nonnull dereferenceable(8) %index, { i64, i8* }* nonnull dereferenceable(16) %str) #2 ; [#uses = 1]
  br label %label.__returnLabel

label.__returnLabel:                              ; preds = %else, %bounds.ok4
  %__result.0 = phi i32 [ %11, %bounds.ok4 ], [ %12, %else ] ; [#uses = 2, type = i32]
  %13 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %__result.0) #2 ; [#uses = 1]
  br i1 %13, label %assertPassed9, label %assertFailed10

assertPassed9:                                    ; preds = %label.__returnLabel
  ret i32 %__result.0

assertFailed10:                                   ; preds = %label.__returnLabel
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1179) #6
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.13, i32 0, i32 0) }, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1175) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFNaKQlKmZw(i64* dereferenceable(8) %index, { i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #0 {
  %.frame = alloca %nest.decodeImpl, align 8      ; [#uses = 15, size/byte = 16]
  %pstr = getelementptr inbounds %nest.decodeImpl, %nest.decodeImpl* %.frame, i64 0, i32 0 ; [#uses = 1, type = i8**]
  %length = getelementptr inbounds %nest.decodeImpl, %nest.decodeImpl* %.frame, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %1, align 8              ; [#uses = 1]
  %2 = load i64, i64* %index, align 8             ; [#uses = 4]
  %3 = getelementptr inbounds i8, i8* %.ptr, i64 %2 ; [#uses = 5, type = i8*]
  store i8* %3, i8** %pstr, align 8
  %4 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %4, align 8              ; [#uses = 1]
  %5 = sub i64 %.len, %2                          ; [#uses = 4]
  store i64 %5, i64* %length, align 8
  %6 = load i8, i8* %3, align 1                   ; [#uses = 4]
  %7 = zext i8 %6 to i32                          ; [#uses = 3]
  %8 = and i32 %7, 192                            ; [#uses = 1]
  %.not = icmp eq i32 %8, 192                     ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %9 = bitcast %nest.decodeImpl* %.frame to i8*   ; [#uses = 1]
  %10 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %9) #0 ; [#uses = 1]
  %11 = bitcast %std.utf.UTFException* %10 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %11) #6
  unreachable

endif:                                            ; preds = %0
  %12 = icmp eq i64 %5, 1                         ; [#uses = 1]
  br i1 %12, label %if3, label %endif4

if3:                                              ; preds = %endif
  %13 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %14 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ11outOfBoundsMFNaNbZCQFhQFg12UTFException(i8* nonnull %13) #0 ; [#uses = 1]
  %15 = bitcast %std.utf.UTFException* %14 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %15) #6
  unreachable

endif4:                                           ; preds = %endif
  %16 = getelementptr inbounds i8, i8* %3, i64 1  ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %16, align 1                 ; [#uses = 1]
  %18 = zext i8 %17 to i32                        ; [#uses = 2]
  %19 = and i32 %18, 192                          ; [#uses = 1]
  %.not75 = icmp eq i32 %19, 128                  ; [#uses = 1]
  br i1 %.not75, label %endif7, label %if6

if6:                                              ; preds = %endif4
  %20 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %21 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %20) #0 ; [#uses = 1]
  %22 = bitcast %std.utf.UTFException* %21 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %22) #6
  unreachable

endif7:                                           ; preds = %endif4
  %23 = shl nuw nsw i32 %7, 6                     ; [#uses = 1]
  %24 = and i32 %18, 63                           ; [#uses = 1]
  %25 = or i32 %24, %23                           ; [#uses = 4]
  %.mask79 = and i8 %6, 32                        ; [#uses = 1]
  %26 = icmp eq i8 %.mask79, 0                    ; [#uses = 1]
  br i1 %26, label %if9, label %unrolledstmt1

if9:                                              ; preds = %endif7
  %27 = and i32 %7, 30                            ; [#uses = 1]
  %28 = icmp eq i32 %27, 0                        ; [#uses = 1]
  br i1 %28, label %if11, label %endif12

if11:                                             ; preds = %if9
  %29 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %30 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %29) #0 ; [#uses = 1]
  %31 = bitcast %std.utf.UTFException* %30 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %31) #6
  unreachable

endif12:                                          ; preds = %if9
  %32 = and i32 %25, 2047                         ; [#uses = 1]
  %33 = add i64 %2, 2                             ; [#uses = 1]
  store i64 %33, i64* %index, align 8
  ret i32 %32

unrolledstmt1:                                    ; preds = %endif7
  %34 = icmp eq i64 %5, 2                         ; [#uses = 1]
  br i1 %34, label %if14, label %endif15

if14:                                             ; preds = %unrolledstmt1
  %35 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %36 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ11outOfBoundsMFNaNbZCQFhQFg12UTFException(i8* nonnull %35) #0 ; [#uses = 1]
  %37 = bitcast %std.utf.UTFException* %36 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %37) #6
  unreachable

endif15:                                          ; preds = %unrolledstmt1
  %38 = getelementptr inbounds i8, i8* %3, i64 2  ; [#uses = 1, type = i8*]
  %39 = load i8, i8* %38, align 1                 ; [#uses = 1]
  %40 = zext i8 %39 to i32                        ; [#uses = 2]
  %41 = and i32 %40, 192                          ; [#uses = 1]
  %.not76 = icmp eq i32 %41, 128                  ; [#uses = 1]
  br i1 %.not76, label %endif18, label %if17

if17:                                             ; preds = %endif15
  %42 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %43 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %42) #0 ; [#uses = 1]
  %44 = bitcast %std.utf.UTFException* %43 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %44) #6
  unreachable

endif18:                                          ; preds = %endif15
  %45 = shl nuw nsw i32 %25, 6                    ; [#uses = 1]
  %46 = and i32 %40, 63                           ; [#uses = 1]
  %47 = or i32 %46, %45                           ; [#uses = 2]
  %.mask80 = and i8 %6, 16                        ; [#uses = 1]
  %48 = icmp eq i8 %.mask80, 0                    ; [#uses = 1]
  br i1 %48, label %if20, label %unrolledstmt2

if20:                                             ; preds = %endif18
  %49 = and i32 %47, 65535                        ; [#uses = 2]
  %50 = and i32 %25, 992                          ; [#uses = 1]
  %51 = icmp eq i32 %50, 0                        ; [#uses = 1]
  br i1 %51, label %if22, label %endif23

if22:                                             ; preds = %if20
  %52 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %53 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %52) #0 ; [#uses = 1]
  %54 = bitcast %std.utf.UTFException* %53 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %54) #6
  unreachable

endif23:                                          ; preds = %if20
  %55 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %49) #2 ; [#uses = 1]
  br i1 %55, label %endif26, label %if25

if25:                                             ; preds = %endif23
  %56 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %57 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %56) #0 ; [#uses = 1]
  %58 = bitcast %std.utf.UTFException* %57 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %58) #6
  unreachable

endif26:                                          ; preds = %endif23
  %59 = load i64, i64* %index, align 8            ; [#uses = 1]
  %60 = add i64 %59, 3                            ; [#uses = 1]
  store i64 %60, i64* %index, align 8
  ret i32 %49

unrolledstmt2:                                    ; preds = %endif18
  %61 = icmp eq i64 %5, 3                         ; [#uses = 1]
  br i1 %61, label %if29, label %endif30

if29:                                             ; preds = %unrolledstmt2
  %62 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %63 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ11outOfBoundsMFNaNbZCQFhQFg12UTFException(i8* nonnull %62) #0 ; [#uses = 1]
  %64 = bitcast %std.utf.UTFException* %63 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %64) #6
  unreachable

endif30:                                          ; preds = %unrolledstmt2
  %65 = getelementptr inbounds i8, i8* %3, i64 3  ; [#uses = 1, type = i8*]
  %66 = load i8, i8* %65, align 1                 ; [#uses = 1]
  %67 = zext i8 %66 to i32                        ; [#uses = 2]
  %68 = and i32 %67, 192                          ; [#uses = 1]
  %.not77 = icmp eq i32 %68, 128                  ; [#uses = 1]
  br i1 %.not77, label %endif33, label %if32

if32:                                             ; preds = %endif30
  %69 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %70 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %69) #0 ; [#uses = 1]
  %71 = bitcast %std.utf.UTFException* %70 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %71) #6
  unreachable

endif33:                                          ; preds = %endif30
  %.mask = and i8 %6, 8                           ; [#uses = 1]
  %.not78 = icmp eq i8 %.mask, 0                  ; [#uses = 1]
  br i1 %.not78, label %if35, label %unrolledend

if35:                                             ; preds = %endif33
  %72 = shl nuw nsw i32 %47, 6                    ; [#uses = 1]
  %73 = and i32 %67, 63                           ; [#uses = 1]
  %.masked = and i32 %72, 2097088                 ; [#uses = 1]
  %74 = or i32 %73, %.masked                      ; [#uses = 2]
  %75 = and i32 %25, 496                          ; [#uses = 1]
  %76 = icmp eq i32 %75, 0                        ; [#uses = 1]
  br i1 %76, label %if37, label %endif38

if37:                                             ; preds = %if35
  %77 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %78 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %77) #0 ; [#uses = 1]
  %79 = bitcast %std.utf.UTFException* %78 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %79) #6
  unreachable

endif38:                                          ; preds = %if35
  %80 = add i64 %2, 4                             ; [#uses = 1]
  store i64 %80, i64* %index, align 8
  %81 = icmp ugt i32 %74, 1114111                 ; [#uses = 1]
  br i1 %81, label %if40, label %endif41

if40:                                             ; preds = %endif38
  %82 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %83 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %82) #0 ; [#uses = 1]
  %84 = bitcast %std.utf.UTFException* %83 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %84) #6
  unreachable

endif41:                                          ; preds = %endif38
  ret i32 %74

unrolledend:                                      ; preds = %endif33
  %85 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %86 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %85) #0 ; [#uses = 1]
  %87 = bitcast %std.utf.UTFException* %86 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %87) #6
  unreachable
}

; [#uses = 9]
declare zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32) local_unnamed_addr #2

; [#uses = 10]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ10invalidUTFMFNaNbZCQFgQFf12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ__T9exceptionTQBcZQpFNaNbNfQBpQDsZCQFvQFu12UTFException({ i64, i8* } { i64 22, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } %5) #2 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ__T9exceptionTQBcZQpFNaNbNfQBpQDsZCQFvQFu12UTFException({ i64, i8* } %msg_arg, { i64, i8* } %str_arg) local_unnamed_addr #0 {
bounds.ok:
  %sequence = alloca [4 x i32], align 4           ; [#uses = 5, size/byte = 16]
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 9]
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 7]
  %exitcond.not = icmp eq i64 %str_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail3, label %bounds.ok2

bounds.ok2:                                       ; preds = %bounds.ok
  %0 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %1 = load i8, i8* %str_arg.fca.1.extract, align 1 ; [#uses = 1]
  %2 = zext i8 %1 to i32                          ; [#uses = 1]
  store i32 %2, i32* %0, align 4
  %.not = icmp eq i64 %str_arg.fca.0.extract, 1   ; [#uses = 1]
  br i1 %.not, label %enddowhile, label %bounds.ok9

bounds.fail3:                                     ; preds = %bounds.ok.3, %bounds.ok.2, %bounds.ok.1, %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #6
  unreachable

bounds.ok9:                                       ; preds = %bounds.ok2
  %3 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %4 = load i8, i8* %3, align 1                   ; [#uses = 1]
  %5 = and i8 %4, -64                             ; [#uses = 1]
  %6 = icmp eq i8 %5, -128                        ; [#uses = 1]
  br i1 %6, label %bounds.ok.1, label %enddowhile

enddowhile:                                       ; preds = %bounds.ok2.3, %bounds.ok2, %bounds.ok9.2, %bounds.ok2.2, %bounds.ok9.1, %bounds.ok2.1, %bounds.ok9
  %.lcssa = phi i64 [ 1, %bounds.ok2 ], [ 1, %bounds.ok9 ], [ 2, %bounds.ok2.1 ], [ 2, %bounds.ok9.1 ], [ 3, %bounds.ok2.2 ], [ 3, %bounds.ok9.2 ], [ 4, %bounds.ok2.3 ] ; [#uses = 2, type = i64]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #4 ; [#uses = 4]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.utf.UTFException* ; [#uses = 2]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl, align 8
  %7 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %7, align 8
  %8 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %9 = bitcast %object.Object* %8 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %9, i8* nonnull align 8 dereferenceable(96) bitcast ({ i64, i8* }* getelementptr inbounds (%std.utf.UTFException, %std.utf.UTFException* @_D3std3utf12UTFException6__initZ, i64 0, i32 2) to i8*), i64 96, i1 false)
  %10 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNfAyamQemC6object9ThrowableZCQCmQClQCk(%std.utf.UTFException* nonnull returned %.newclass_gc, %object.Throwable* null, i64 1547, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i64 %.lcssa, { i64, i8* } %msg_arg) #2 ; [#uses = 0]
  %11 = load [11 x i8*]*, [11 x i8*]** %vtbl, align 8 ; [#uses = 1]
  %"setSequence@vtbl" = getelementptr inbounds [11 x i8*], [11 x i8*]* %11, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %12 = bitcast i8** %"setSequence@vtbl" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %13 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %12, align 8 ; [#uses = 1]
  %14 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %15 = insertvalue { i64, i32* } undef, i64 %.lcssa, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i32* } %15, i32* %14, 1 ; [#uses = 1]
  %17 = call %std.utf.UTFException* %13(%std.utf.UTFException* nonnull %.newclass_gc, { i64, i32* } %16) ; [#uses = 1]
  ret %std.utf.UTFException* %17

bounds.ok.1:                                      ; preds = %bounds.ok9
  %exitcond.not.1 = icmp eq i64 %str_arg.fca.0.extract, 1 ; [#uses = 1]
  br i1 %exitcond.not.1, label %bounds.fail3, label %bounds.ok2.1

bounds.ok2.1:                                     ; preds = %bounds.ok.1
  %18 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 1 ; [#uses = 1, type = i32*]
  %19 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %20 = load i8, i8* %19, align 1                 ; [#uses = 1]
  %21 = zext i8 %20 to i32                        ; [#uses = 1]
  store i32 %21, i32* %18, align 4
  %22 = icmp ugt i64 %str_arg.fca.0.extract, 2    ; [#uses = 1]
  br i1 %22, label %bounds.ok9.1, label %enddowhile

bounds.ok9.1:                                     ; preds = %bounds.ok2.1
  %23 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = and i8 %24, -64                           ; [#uses = 1]
  %26 = icmp eq i8 %25, -128                      ; [#uses = 1]
  br i1 %26, label %bounds.ok.2, label %enddowhile

bounds.ok.2:                                      ; preds = %bounds.ok9.1
  %exitcond.not.2 = icmp eq i64 %str_arg.fca.0.extract, 2 ; [#uses = 1]
  br i1 %exitcond.not.2, label %bounds.fail3, label %bounds.ok2.2

bounds.ok2.2:                                     ; preds = %bounds.ok.2
  %27 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 2 ; [#uses = 1, type = i32*]
  %28 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 2 ; [#uses = 1, type = i8*]
  %29 = load i8, i8* %28, align 1                 ; [#uses = 1]
  %30 = zext i8 %29 to i32                        ; [#uses = 1]
  store i32 %30, i32* %27, align 4
  %31 = icmp ugt i64 %str_arg.fca.0.extract, 3    ; [#uses = 1]
  br i1 %31, label %bounds.ok9.2, label %enddowhile

bounds.ok9.2:                                     ; preds = %bounds.ok2.2
  %32 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 3 ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %34 = and i8 %33, -64                           ; [#uses = 1]
  %35 = icmp eq i8 %34, -128                      ; [#uses = 1]
  br i1 %35, label %bounds.ok.3, label %enddowhile

bounds.ok.3:                                      ; preds = %bounds.ok9.2
  %exitcond.not.3 = icmp eq i64 %str_arg.fca.0.extract, 3 ; [#uses = 1]
  br i1 %exitcond.not.3, label %bounds.fail3, label %bounds.ok2.3

bounds.ok2.3:                                     ; preds = %bounds.ok.3
  %36 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 3 ; [#uses = 1, type = i32*]
  %37 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 3 ; [#uses = 1, type = i8*]
  %38 = load i8, i8* %37, align 1                 ; [#uses = 1]
  %39 = zext i8 %38 to i32                        ; [#uses = 1]
  store i32 %39, i32* %36, align 4
  br label %enddowhile
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ11outOfBoundsMFNaNbZCQFhQFg12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ__T9exceptionTQBcZQpFNaNbNfQBpQDsZCQFvQFu12UTFException({ i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.13, i32 0, i32 0) }, { i64, i8* } %5) #2 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

; [#uses = 2]
declare %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNfAyamQemC6object9ThrowableZCQCmQClQCk(%std.utf.UTFException* nonnull returned, %object.Throwable*, i64, { i64, i8* }, i64, { i64, i8* }) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* }* @_D4core8lifetime__T7emplaceTAyaTQeZQqFNaNbNiNfPQtKQwZQh({ i64, i8* }* dereferenceable(16) %_param_1, { i64, i8* }* %chunk_arg) local_unnamed_addr #0 {
  %1 = bitcast { i64, i8* }* %chunk_arg to i8*    ; [#uses = 1]
  tail call void @llvm.memset.p0i8.i64(i8* nonnull align 1 dereferenceable(16) %1, i8 0, i64 16, i1 false) #2
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_1, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %3 = bitcast i8** %2 to i64*                    ; [#uses = 1]
  %.ptr1.i.i = load i64, i64* %3, align 8         ; [#uses = 1]
  %4 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_1, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i = load i64, i64* %4, align 8          ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %chunk_arg, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len.i.i, i64* %5, align 8
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %chunk_arg, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %7 = bitcast i8** %6 to i64*                    ; [#uses = 1]
  store i64 %.ptr1.i.i, i64* %7, align 8
  ret { i64, i8* }* %chunk_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm10comparison__T3maxTmTiZQjFNaNbNiNfmiZm(i32 %_param_1_arg, i64 %_param_0_arg) local_unnamed_addr #0 {
condend:
  %0 = icmp sgt i32 %_param_1_arg, -1             ; [#uses = 1]
  br i1 %0, label %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTmTiZQBbFNaNbNiNfKmKiZb.exit, label %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTmTiZQBbFNaNbNiNfKmKiZb.exit.thread

_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTmTiZQBbFNaNbNiNfKmKiZb.exit: ; preds = %condend
  %1 = zext i32 %_param_1_arg to i64              ; [#uses = 2]
  %2 = icmp ugt i64 %1, %_param_0_arg             ; [#uses = 1]
  %spec.select = select i1 %2, i64 %1, i64 %_param_0_arg ; [#uses = 1]
  ret i64 %spec.select

_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTmTiZQBbFNaNbNiNfKmKiZb.exit.thread: ; preds = %condend
  ret i64 %_param_0_arg
}

; [#uses = 2]
; Function Attrs: nounwind readnone speculatable willreturn
declare i64 @llvm.ctlz.i64(i64, i1 immarg) #10

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm10comparison__T3maxTmTmZQjFNaNbNiNfmmZm(i64 %b_arg, i64 %a_arg) local_unnamed_addr #0 {
condend:
  %0 = icmp ult i64 %a_arg, %b_arg                ; [#uses = 1]
  %b_arg.a_arg = select i1 %0, i64 %b_arg, i64 %a_arg ; [#uses = 1]
  ret i64 %b_arg.a_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTmTiZQBbFNaNbNiNfKmKiZb(i32* dereferenceable(4) %b, i64* dereferenceable(8) %a) local_unnamed_addr #0 {
  %1 = load i32, i32* %b, align 4                 ; [#uses = 2]
  %2 = icmp sgt i32 %1, -1                        ; [#uses = 1]
  br i1 %2, label %andand, label %andandend

andand:                                           ; preds = %0
  %3 = load i64, i64* %a, align 8                 ; [#uses = 1]
  %4 = zext i32 %1 to i64                         ; [#uses = 1]
  %5 = icmp ult i64 %3, %4                        ; [#uses = 1]
  br label %andandend

andandend:                                        ; preds = %andand, %0
  %andandval = phi i1 [ false, %0 ], [ %5, %andand ] ; [#uses = 1, type = i1]
  ret i1 %andandval
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T6safeOpVAyaa1_3cZ__T8unsafeOpTmTiZQoFNaNbNiNfmiZb(i32 %b_arg, i64 %a_arg) local_unnamed_addr #0 {
  %1 = sext i32 %b_arg to i64                     ; [#uses = 1]
  %2 = icmp ugt i64 %1, %a_arg                    ; [#uses = 1]
  ret i1 %2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8internal8lifetime__T10emplaceRefTAyaTQeTQhZQxFNaNbNiNfKQwKQzZv({ i64, i8* }* dereferenceable(16) %_param_1, { i64, i8* }* dereferenceable(16) %chunk) local_unnamed_addr #0 {
  %1 = bitcast { i64, i8* }* %chunk to i8*        ; [#uses = 1]
  tail call void @llvm.memset.p0i8.i64(i8* nonnull align 1 dereferenceable(16) %1, i8 0, i64 16, i1 false) #2
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_1, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %3 = bitcast i8** %2 to i64*                    ; [#uses = 1]
  %.ptr1.i = load i64, i64* %3, align 8           ; [#uses = 1]
  %4 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_1, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %4, align 8            ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %chunk, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len.i, i64* %5, align 8
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %chunk, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %7 = bitcast i8** %6 to i64*                    ; [#uses = 1]
  store i64 %.ptr1.i, i64* %7, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D4core8internal8lifetime__T10emplaceRefTAyaTQeTQhZQxFKQoKQrZ1S11__xopEqualsFKxSQDaQCyQCs__TQCmTQCdTQChTQClZQDcFKQCuKQCyZQCiKxQBvZb(%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* dereferenceable(16) %q, %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %p, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %p, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %.elt3 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %q, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack4 = load i64, i64* %.elt3, align 8      ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack4, 0 ; [#uses = 1]
  %.elt5 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %q, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6 = load i8*, i8** %.elt5, align 8      ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack6, 1 ; [#uses = 1]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #0 ; [#uses = 1]
  ret i1 %5
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D4core8internal8lifetime__T10emplaceRefTAyaTQeTQhZQxFKQoKQrZ1S9__xtoHashFNbNeKxSQDbQCzQCt__TQCnTQCeTQCiTQCmZQDdFKQCvKQCzZQCjZm(%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* dereferenceable(16) %p) local_unnamed_addr #0 {
unrolledstmt:
  %0 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D13TypeInfo_xAya6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl" = getelementptr inbounds [19 x i8*], [19 x i8*]* %0, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %1 = bitcast i8** %"getHash@vtbl" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %2 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %1, align 8 ; [#uses = 1]
  %3 = bitcast %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D13TypeInfo_xAya6__initZ, i8* nonnull %3) ; [#uses = 1]
  ret i64 %4
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8internal8lifetime__T18emplaceInitializerTSQBwQBuQBo__T10emplaceRefTAyaTQeTQhZQxFKQoKQrZ1SZQCsFNaNbNiNeMKQClZv(%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* dereferenceable(16) %chunk) local_unnamed_addr #0 {
  %1 = bitcast %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %chunk to i8* ; [#uses = 1]
  tail call void @llvm.memset.p0i8.i64(i8* nonnull align 1 dereferenceable(16) %1, i8 0, i64 16, i1 false) #2
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* @_D4core8internal8lifetime__T10emplaceRefTAyaTQeTQhZQxFKQoKQrZ1S__T6__ctorZQiMFNaNbNcNiNfKQBwZSQDoQDmQDg__TQDaTQCrTQCvTQCzZQDqFKQDiKQDmZQCw(%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* nonnull returned %.this_arg, { i64, i8* }* dereferenceable(16) %_param_0) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_0, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %2 = bitcast i8** %1 to i64*                    ; [#uses = 1]
  %.ptr1 = load i64, i64* %2, align 8             ; [#uses = 1]
  %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %_param_0, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  %4 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %4, align 8
  %5 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 1]
  store i64 %.ptr1, i64* %6, align 8
  ret %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %.this_arg
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i64 @_D3std4conv__T6toImplTlTAyaZQoFNaNfQlZl({ i64, i8* } %value_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %value = alloca { i64, i8* }, align 8           ; [#uses = 3, size/byte = 16]
  %value_arg.fca.0.extract = extractvalue { i64, i8* } %value_arg, 0 ; [#uses = 1]
  %value_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %value, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %value_arg.fca.0.extract, i64* %value_arg.fca.0.gep, align 8
  %value_arg.fca.1.extract = extractvalue { i64, i8* } %value_arg, 1 ; [#uses = 1]
  %value_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %value, i64 0, i32 1 ; [#uses = 2, type = i8**]
  store i8* %value_arg.fca.1.extract, i8** %value_arg.fca.1.gep, align 8
  %1 = invoke i64 @_D3std4conv__T5parseTlTAyaVEQBa8typecons__T4FlagVQBaa7_646f436f756e74ZQBbi0ZQCkFNaNfKQCkZl({ i64, i8* }* nonnull dereferenceable(16) %value) #0
          to label %if unwind label %landingPad4  ; [#uses = 1]

return:                                           ; preds = %if
  ret i64 %1

catch.object.Throwable:                           ; preds = %landingPad4
  %2 = call %object.Throwable* @_d_eh_enter_catch(i8* %8) ; [#uses = 1]
  invoke void @_d_throw_exception(%object.Throwable* %2) #6
          to label %postinvoke unwind label %endif.thread

postinvoke:                                       ; preds = %catch.object.Throwable
  unreachable

endif.thread:                                     ; preds = %catch.object.Throwable
  %3 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %4 = extractvalue { i8*, i32 } %3, 0            ; [#uses = 1]
  br label %eh.resume

if:                                               ; preds = %0
  %.len.i = load i64, i64* %value_arg.fca.0.gep, align 8 ; [#uses = 2]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br i1 %.not.i, label %return, label %if1

if.thread:                                        ; preds = %landingPad4
  %.len.i25 = load i64, i64* %value_arg.fca.0.gep, align 8 ; [#uses = 2]
  %.not.i26 = icmp eq i64 %.len.i25, 0            ; [#uses = 1]
  br i1 %.not.i26, label %eh.resume, label %if1

if1:                                              ; preds = %if.thread, %if
  %.len.i30 = phi i64 [ %.len.i25, %if.thread ], [ %.len.i, %if ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.len.i30, 0 ; [#uses = 1]
  %.fca.1.load = load i8*, i8** %value_arg.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  %5 = call %std.conv.ConvException* @_D3std4conv__T9convErrorTAyaTlZQrFNaNfQnQpmZCQBrQBq13ConvException(i64 1967, { i64, i8* } { i64 50, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.18, i32 0, i32 0) }, { i64, i8* } %.fca.1.insert) #0 ; [#uses = 1]
  %6 = bitcast %std.conv.ConvException* %5 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %6) #6
  unreachable

eh.resume:                                        ; preds = %if.thread, %endif.thread
  %eh.ptr.01121 = phi i8* [ %4, %endif.thread ], [ %8, %if.thread ] ; [#uses = 1, type = i8*]
  call void @_Unwind_Resume(i8* %eh.ptr.01121)
  unreachable

landingPad4:                                      ; preds = %0
  %7 = landingpad { i8*, i32 }
          cleanup
          catch %object.TypeInfo_Class* @_D6object9Throwable7__ClassZ ; [#uses = 2]
  %8 = extractvalue { i8*, i32 } %7, 0            ; [#uses = 2]
  %9 = extractvalue { i8*, i32 } %7, 1            ; [#uses = 1]
  %10 = call i32 @llvm.eh.typeid.for(i8* bitcast (%object.TypeInfo_Class* @_D6object9Throwable7__ClassZ to i8*)) ; [#uses = 1]
  %11 = icmp eq i32 %9, %10                       ; [#uses = 1]
  br i1 %11, label %catch.object.Throwable, label %if.thread
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std4conv__T5parseTlTAyaVEQBa8typecons__T4FlagVQBaa7_646f436f756e74ZQBbi0ZQCkFNaNfKQCkZl({ i64, i8* }* dereferenceable(16) %s) local_unnamed_addr #0 {
  %source = alloca { i64, i8* }, align 8          ; [#uses = 5, size/byte = 16]
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %s, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 3]
  %.elt53 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %s, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %.unpack54 = load i8*, i8** %.elt53, align 8    ; [#uses = 2]
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 0 ; [#uses = 5, type = i64*]
  store i64 %.unpack, i64* %1, align 8
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 1 ; [#uses = 5, type = i8**]
  store i8* %.unpack54, i8** %2, align 8
  %.not.i = icmp eq i64 %.unpack, 0               ; [#uses = 1]
  br i1 %.not.i, label %label.Lerr, label %endif

endif:                                            ; preds = %0
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack54, 1 ; [#uses = 1]
  %5 = tail call i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %4) #2 ; [#uses = 1]
  %6 = load i8, i8* %5, align 1                   ; [#uses = 2]
  switch i8 %6, label %switchend [
    i8 45, label %case
    i8 43, label %goto_case
  ]

case:                                             ; preds = %endif
  br label %goto_case

goto_case:                                        ; preds = %endif, %case
  %sign.0 = phi i8 [ 0, %endif ], [ 1, %case ]    ; [#uses = 1, type = i8]
  call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %source) #2
  %.len.i57 = load i64, i64* %1, align 8          ; [#uses = 2]
  %.not.i58 = icmp eq i64 %.len.i57, 0            ; [#uses = 1]
  br i1 %.not.i58, label %label.Lerr, label %endif2

endif2:                                           ; preds = %goto_case
  %.fca.0.insert35 = insertvalue { i64, i8* } undef, i64 %.len.i57, 0 ; [#uses = 1]
  %.fca.1.load37 = load i8*, i8** %2, align 8     ; [#uses = 1]
  %.fca.1.insert38 = insertvalue { i64, i8* } %.fca.0.insert35, i8* %.fca.1.load37, 1 ; [#uses = 1]
  %7 = call i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %.fca.1.insert38) #2 ; [#uses = 1]
  %8 = load i8, i8* %7, align 1                   ; [#uses = 1]
  br label %switchend

switchend:                                        ; preds = %endif, %endif2
  %sign.1 = phi i8 [ 0, %endif ], [ %sign.0, %endif2 ] ; [#uses = 2, type = i8]
  %c.0.in = phi i8 [ %6, %endif ], [ %8, %endif2 ] ; [#uses = 1, type = i8]
  %c.0 = zext i8 %c.0.in to i32                   ; [#uses = 1]
  %9 = add nsw i32 %c.0, -48                      ; [#uses = 2]
  %10 = icmp ult i32 %9, 10                       ; [#uses = 1]
  br i1 %10, label %if7, label %switchend.label.Lerr_crit_edge

switchend.label.Lerr_crit_edge:                   ; preds = %switchend
  %.len21.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %label.Lerr

if7:                                              ; preds = %switchend
  %11 = zext i32 %9 to i64                        ; [#uses = 1]
  call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %source) #2
  %narrow = add nuw nsw i8 %sign.1, 7             ; [#uses = 1]
  %12 = zext i8 %narrow to i32                    ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %if15, %if7
  %v.0 = phi i64 [ %11, %if7 ], [ %23, %if15 ]    ; [#uses = 6, type = i64]
  %.len.i59 = load i64, i64* %1, align 8          ; [#uses = 2]
  %.not.i60 = icmp eq i64 %.len.i59, 0            ; [#uses = 1]
  br i1 %.not.i60, label %endfor, label %forbody

forbody:                                          ; preds = %forcond
  %.fca.0.insert41 = insertvalue { i64, i8* } undef, i64 %.len.i59, 0 ; [#uses = 1]
  %.fca.1.load43 = load i8*, i8** %2, align 8     ; [#uses = 1]
  %.fca.1.insert44 = insertvalue { i64, i8* } %.fca.0.insert41, i8* %.fca.1.load43, 1 ; [#uses = 1]
  %13 = call i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %.fca.1.insert44) #2 ; [#uses = 1]
  %14 = load i8, i8* %13, align 1                 ; [#uses = 1]
  %15 = zext i8 %14 to i32                        ; [#uses = 1]
  %16 = add nsw i32 %15, -48                      ; [#uses = 3]
  %17 = icmp ugt i32 %16, 9                       ; [#uses = 1]
  br i1 %17, label %forbody.endfor_crit_edge, label %endif10

forbody.endfor_crit_edge:                         ; preds = %forbody
  %.len19.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endfor

endif10:                                          ; preds = %forbody
  %18 = icmp sgt i64 %v.0, -1                     ; [#uses = 1]
  br i1 %18, label %andand, label %else

andand:                                           ; preds = %endif10
  %19 = icmp slt i64 %v.0, 922337203685477580     ; [#uses = 1]
  br i1 %19, label %if15, label %oror

oror:                                             ; preds = %andand
  %20 = icmp ne i64 %v.0, 922337203685477580      ; [#uses = 1]
  %.not56 = icmp ugt i32 %16, %12                 ; [#uses = 1]
  %or.cond = or i1 %20, %.not56                   ; [#uses = 1]
  br i1 %or.cond, label %else, label %if15

if15:                                             ; preds = %oror, %andand
  %21 = mul nuw nsw i64 %v.0, 10                  ; [#uses = 1]
  %22 = zext i32 %16 to i64                       ; [#uses = 1]
  %23 = add nuw i64 %21, %22                      ; [#uses = 1]
  call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %source) #2
  br label %forcond

else:                                             ; preds = %oror, %endif10
  %.newclass_gc_alloc = call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std4conv21ConvOverflowException7__ClassZ) #4 ; [#uses = 5]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.conv.ConvOverflowException* ; [#uses = 1]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D3std4conv21ConvOverflowException6__vtblZ, [10 x i8*]** %vtbl, align 8
  %24 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %24, align 8
  %25 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %26 = bitcast %object.Object* %25 to i8*        ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(60) %26, i8* nonnull align 8 dereferenceable(60) bitcast ({ i64, i8* }* getelementptr inbounds (%std.conv.ConvOverflowException, %std.conv.ConvOverflowException* @_D3std4conv21ConvOverflowException6__initZ, i64 0, i32 2) to i8*), i64 60, i1 false)
  %27 = call %std.conv.ConvOverflowException* @_D3std4conv21ConvOverflowException6__ctorMFNaNbNfAyaQdmZCQCdQCcQCa(%std.conv.ConvOverflowException* nonnull returned %.newclass_gc, i64 2480, { i64, i8* } { i64 50, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.18, i32 0, i32 0) }, { i64, i8* } { i64 31, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.17, i32 0, i32 0) }) #2 ; [#uses = 0]
  %28 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %28) #6
  unreachable

endfor:                                           ; preds = %forcond, %forbody.endfor_crit_edge
  %.len19 = phi i64 [ %.len19.pre, %forbody.endfor_crit_edge ], [ 0, %forcond ] ; [#uses = 1, type = i64]
  %.not = icmp eq i8 %sign.1, 0                   ; [#uses = 1]
  %negval = sub i64 0, %v.0                       ; [#uses = 1]
  %spec.select = select i1 %.not, i64 %v.0, i64 %negval ; [#uses = 1]
  %29 = bitcast i8** %2 to i64*                   ; [#uses = 1]
  %.ptr2055 = load i64, i64* %29, align 8         ; [#uses = 1]
  store i64 %.len19, i64* %.elt, align 8
  %30 = bitcast i8** %.elt53 to i64*              ; [#uses = 1]
  store i64 %.ptr2055, i64* %30, align 8
  ret i64 %spec.select

label.Lerr:                                       ; preds = %switchend.label.Lerr_crit_edge, %goto_case, %0
  %.len21 = phi i64 [ %.len21.pre, %switchend.label.Lerr_crit_edge ], [ 0, %goto_case ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.ptr22 = load i8*, i8** %2, align 8            ; [#uses = 1]
  %31 = insertvalue { i64, i8* } undef, i64 %.len21, 0 ; [#uses = 1]
  %32 = insertvalue { i64, i8* } %31, i8* %.ptr22, 1 ; [#uses = 1]
  %33 = call %std.conv.ConvException* @_D3std4conv__T9convErrorTAyaTlZQrFNaNfQnQpmZCQBrQBq13ConvException(i64 2500, { i64, i8* } { i64 50, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.18, i32 0, i32 0) }, { i64, i8* } %32) #2 ; [#uses = 1]
  %34 = bitcast %std.conv.ConvException* %33 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %34) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std6string__T14representationTyaZQuFNaNbNiNfAyaZAyh({ i64, i8* } %s_arg) local_unnamed_addr #0 {
  ret { i64, i8* } %s_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAyhZQlFNaNbNdNiNfMKQtZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  ret i1 %.not
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 1]
  %.not = icmp eq i64 %a_arg.fca.0.extract, 0     ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %a_arg.fca.1.extract = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  ret i8* %a_arg.fca.1.extract

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 56, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.19, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.9, i32 0, i32 0) }, i32 2472) #6
  unreachable
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 1 ; [#uses = 1, type = i8*]
  %3 = add i64 %.len, -1                          ; [#uses = 1]
  store i64 %3, i64* %1, align 8
  store i8* %lowerbound, i8** %2, align 8
  ret void

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 58, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.20, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.9, i32 0, i32 0) }, i32 2275) #6
  unreachable
}

; [#uses = 1]
declare %std.conv.ConvOverflowException* @_D3std4conv21ConvOverflowException6__ctorMFNaNbNfAyaQdmZCQCdQCcQCa(%std.conv.ConvOverflowException* nonnull returned, i64, { i64, i8* }, { i64, i8* }) local_unnamed_addr #2

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.conv.ConvException* @_D3std4conv__T9convErrorTAyaTlZQrFNaNfQnQpmZCQBrQBq13ConvException(i64 %ln_arg, { i64, i8* } %fn_arg, { i64, i8* } %source_arg) local_unnamed_addr #0 {
  %.lval_copy_for_ImplicitByvalRewrite = alloca { i64, i8* }, align 8 ; [#uses = 3, size/byte = 16]
  %source_arg.fca.0.extract = extractvalue { i64, i8* } %source_arg, 0 ; [#uses = 1]
  %.not.i = icmp eq i64 %source_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not.i, label %endif, label %else

else:                                             ; preds = %0
  %1 = tail call i32 @_D3std5range10primitives__T5frontTaZQjFNaNdNfMAxaZw({ i64, i8* } %source_arg) #0 ; [#uses = 2]
  %2 = icmp eq i32 %1, 10                         ; [#uses = 1]
  br i1 %2, label %endif, label %else3

else3:                                            ; preds = %else
  %3 = tail call { i64, i8* } @_D3std4conv__T8textImplTAyaTQeTwTQjZQwFNaNfQtwQwZQz({ i64, i8* } { i64 47, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.24, i32 0, i32 0) }, i32 %1, { i64, i8* } { i64 12, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.23, i32 0, i32 0) }) #2 ; [#uses = 2]
  %.ptr6 = extractvalue { i64, i8* } %3, 1        ; [#uses = 1]
  %.len7 = extractvalue { i64, i8* } %3, 0        ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %else, %0, %else3
  %msg.sroa.0.0 = phi i64 [ %.len7, %else3 ], [ 69, %0 ], [ 61, %else ] ; [#uses = 1, type = i64]
  %msg.sroa.5.0 = phi i8* [ %.ptr6, %else3 ], [ getelementptr inbounds ([70 x i8], [70 x i8]* @.str.21, i64 0, i64 0), %0 ], [ getelementptr inbounds ([62 x i8], [62 x i8]* @.str.22, i64 0, i64 0), %else ] ; [#uses = 1, type = i8*]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std4conv13ConvException7__ClassZ) #4 ; [#uses = 4]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.conv.ConvException* ; [#uses = 2]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D3std4conv13ConvException6__vtblZ, [10 x i8*]** %vtbl, align 8
  %4 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %4, align 8
  %5 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %6 = bitcast %object.Object* %5 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(60) %6, i8* nonnull align 8 dereferenceable(60) bitcast ({ i64, i8* }* getelementptr inbounds (%std.conv.ConvException, %std.conv.ConvException* @_D3std4conv13ConvException6__initZ, i64 0, i32 2) to i8*), i64 60, i1 false)
  %msg.sroa.0.0..sroa_idx = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %msg.sroa.0.0, i64* %msg.sroa.0.0..sroa_idx, align 8
  %msg.sroa.5.0..sroa_idx9 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %msg.sroa.5.0, i8** %msg.sroa.5.0..sroa_idx9, align 8
  %7 = tail call %std.conv.ConvException* @_D3std4conv13ConvException8__mixin26__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCyQCxQCv(%std.conv.ConvException* nonnull returned %.newclass_gc, %object.Throwable* null, i64 %ln_arg, { i64, i8* } %fn_arg, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #2 ; [#uses = 0]
  ret %std.conv.ConvException* %.newclass_gc
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T4textTAyaZQkFNaNbNiNfQpZQs({ i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  ret { i64, i8* } %_param_0_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T4textTAyaTwTQgZQpFNaNfQqwQtZQw({ i64, i8* } %_param_2_arg, i32 %_param_1_arg, { i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  %1 = tail call { i64, i8* } @_D3std4conv__T8textImplTAyaTQeTwTQjZQwFNaNfQtwQwZQz({ i64, i8* } %_param_2_arg, i32 %_param_1_arg, { i64, i8* } %_param_0_arg) #2 ; [#uses = 1]
  ret { i64, i8* } %1
}

; [#uses = 1]
declare %std.conv.ConvException* @_D3std4conv13ConvException8__mixin26__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCyQCxQCv(%std.conv.ConvException* nonnull returned, %object.Throwable*, i64, { i64, i8* }, { i64, i8* }* byval align 8) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T8textImplTAyaTQeZQrFNaNbNiNfQsZQv({ i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  ret { i64, i8* } %_param_0_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T2toTAyaZ__TQlTQkZQrFNaNbNiNfQyZQBb({ i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  ret { i64, i8* } %_param_0_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T6toImplTAyaTQeZQpFNaNbNiNfQsZQv({ i64, i8* } %value_arg) local_unnamed_addr #0 {
  ret { i64, i8* } %value_arg
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std4conv__T8textImplTAyaTQeTwTQjZQwFNaNfQtwQwZQz({ i64, i8* } %_param_2_arg, i32 %_param_1_arg, { i64, i8* } %_param_0_arg) local_unnamed_addr #0 {
  %app = alloca %"std.array.Appender!string.Appender", align 8 ; [#uses = 5, size/byte = 8]
  %1 = tail call %"std.array.Appender!string.Appender" @_D3std5array__T8appenderTAyaZQoFNaNbNfZSQBmQBl__T8AppenderTQBiZQo() #2 ; [#uses = 1]
  %.fca.0.extract = extractvalue %"std.array.Appender!string.Appender" %1, 0 ; [#uses = 1]
  %.sroa.0.0..sroa_idx = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %app, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!string.Appender.Data"**]
  store %"std.array.Appender!string.Appender.Data"* %.fca.0.extract, %"std.array.Appender!string.Appender.Data"** %.sroa.0.0..sroa_idx, align 8
  call void @_D3std5array__T8AppenderTAyaZQo7reserveMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %app, i64 60) #2
  call void @_D3std5array__T8AppenderTAyaZQo__T3putTQoZQiMFNaNbNfQBbZv(%"std.array.Appender!string.Appender"* nonnull %app, { i64, i8* } %_param_0_arg) #2
  call void @_D3std5array__T8AppenderTAyaZQo__T3putTwZQhMFNaNfwZv(%"std.array.Appender!string.Appender"* nonnull %app, i32 %_param_1_arg) #2
  call void @_D3std5array__T8AppenderTAyaZQo__T3putTQoZQiMFNaNbNfQBbZv(%"std.array.Appender!string.Appender"* nonnull %app, { i64, i8* } %_param_2_arg) #2
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 3]
  %.not.i.i = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std5array__T8AppenderTAyaZQo4dataMNgFNaNbNdNiNeZQBa.exit, label %condtrue.i.i

condtrue.i.i:                                     ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i = load i64, i64* %3, align 8          ; [#uses = 1]
  %4 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr.i.i = load i8*, i8** %4, align 8          ; [#uses = 1]
  br label %_D3std5array__T8AppenderTAyaZQo4dataMNgFNaNbNdNiNeZQBa.exit

_D3std5array__T8AppenderTAyaZQo4dataMNgFNaNbNdNiNeZQBa.exit: ; preds = %0, %condtrue.i.i
  %condtmp.0.sroa.phi14.sroa.speculated.i.i = phi i64 [ %.len.i.i, %condtrue.i.i ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %condtmp.0.sroa.phi17.sroa.speculated.i.i = phi i8* [ %.ptr.i.i, %condtrue.i.i ], [ null, %0 ] ; [#uses = 1, type = i8*]
  %.fca.0.insert7.i.i = insertvalue { i64, i8* } undef, i64 %condtmp.0.sroa.phi14.sroa.speculated.i.i, 0 ; [#uses = 1]
  %.fca.1.insert10.i.i = insertvalue { i64, i8* } %.fca.0.insert7.i.i, i8* %condtmp.0.sroa.phi17.sroa.speculated.i.i, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert10.i.i
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.array.Appender!string.Appender" @_D3std5array__T8appenderTAyaZQoFNaNbNfZSQBmQBl__T8AppenderTQBiZQo() local_unnamed_addr #0 {
  %.structliteral = alloca %"std.array.Appender!string.Appender", align 8 ; [#uses = 2, size/byte = 8]
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.structliteral, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!string.Appender.Data"**]
  store %"std.array.Appender!string.Appender.Data"* null, %"std.array.Appender!string.Appender.Data"** %1, align 8
  %2 = call %"std.array.Appender!string.Appender"* @_D3std5array__T8AppenderTAyaZQo6__ctorMFNaNbNcNeQxZSQByQBx__TQBuTQBoZQCc(%"std.array.Appender!string.Appender"* nonnull returned %.structliteral, { i64, i8* } zeroinitializer) #2 ; [#uses = 0]
  %.fca.0.load = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 1]
  %.fca.0.insert = insertvalue %"std.array.Appender!string.Appender" undef, %"std.array.Appender!string.Appender.Data"* %.fca.0.load, 0 ; [#uses = 1]
  ret %"std.array.Appender!string.Appender" %.fca.0.insert
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAyaZQo7reserveMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, i64 %newCapacity_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %endif.sink.split, label %if

if:                                               ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = icmp ult i64 %4, %newCapacity_arg          ; [#uses = 1]
  br i1 %5, label %if1, label %endif

if1:                                              ; preds = %if
  %6 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %6, align 8              ; [#uses = 1]
  %7 = sub i64 %newCapacity_arg, %.len            ; [#uses = 1]
  br label %endif.sink.split

endif.sink.split:                                 ; preds = %0, %if1
  %.sink = phi i64 [ %7, %if1 ], [ %newCapacity_arg, %0 ] ; [#uses = 1, type = i64]
  tail call void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, i64 %.sink) #2
  br label %endif

endif:                                            ; preds = %endif.sink.split, %if
  ret void
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAyaZQo__T3putTQoZQiMFNaNbNfQBbZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, { i64, i8* } %items_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.put.2, align 8           ; [#uses = 2, size/byte = 8]
  %items_arg.fca.0.extract = extractvalue { i64, i8* } %items_arg, 0 ; [#uses = 2]
  %this = getelementptr inbounds %nest.put.2, %nest.put.2* %.frame, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender"**]
  store %"std.array.Appender!string.Appender"* %.this_arg, %"std.array.Appender!string.Appender"** %this, align 8
  %1 = bitcast %nest.put.2* %.frame to i8*        ; [#uses = 1]
  %2 = call { i64, i8* } @_D3std5array__T8AppenderTAyaZQo__T3putTQoZQiMFQvZ10bigDataFunMFNaNbNfmZAa(i8* nonnull %1, i64 %items_arg.fca.0.extract) #0 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %2, 1         ; [#uses = 2]
  %.len1 = extractvalue { i64, i8* } %2, 0        ; [#uses = 5]
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!string.Appender.Data"**]
  %4 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 1]
  %5 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2 = load i64, i64* %5, align 8             ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len1, %.len2 ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %items_arg.fca.1.extract = extractvalue { i64, i8* } %items_arg, 1 ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %.len2 ; [#uses = 1, type = i8*]
  %6 = sub i64 %.len1, %.len2                     ; [#uses = 1]
  call void @_d_array_slice_copy(i8* nocapture %lowerbound, i64 %6, i8* nocapture %items_arg.fca.1.extract, i64 %items_arg.fca.0.extract, i64 1) #4
  %7 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 2]
  %8 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %7, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len1, i64* %8, align 8
  %9 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %7, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr, i8** %9, align 8
  ret void

bounds.fail:                                      ; preds = %0
  call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 3571, i64 %.len2, i64 %.len1, i64 %.len1) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAyaZQo__T3putTwZQhMFNaNfwZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, i32 %item_arg) local_unnamed_addr #0 {
  %encoded = alloca i32, align 4                  ; [#uses = 3, size/byte = 4]
  %tmpcast = bitcast i32* %encoded to [4 x i8]*   ; [#uses = 1]
  store i32 -1, i32* %encoded, align 4
  %1 = call i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG4awZm(i32 %item_arg, [4 x i8]* nonnull dereferenceable(4) %tmpcast) #2 ; [#uses = 3]
  %bounds.cmp.up = icmp ult i64 %1, 5             ; [#uses = 1]
  br i1 %bounds.cmp.up, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %0
  %2 = bitcast i32* %encoded to i8*               ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %1, 0  ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %2, 1     ; [#uses = 1]
  call void @_D3std5array__T8AppenderTAyaZQo__T3putTAaZQiMFNaNbNfQnZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, { i64, i8* } %4) #2
  ret void

bounds.fail:                                      ; preds = %0
  call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 3504, i64 0, i64 %1, i64 4) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T8AppenderTAyaZQo4dataMNgFNaNbNdNiNeZQBa(%"std.array.Appender!string.Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not.i = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not.i, label %_D3std5array__T8AppenderTAyaZQo7opSliceMNgFNaNbNdNiNeZQBd.exit, label %condtrue.i

condtrue.i:                                       ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %3, align 8            ; [#uses = 1]
  %4 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr.i = load i8*, i8** %4, align 8            ; [#uses = 1]
  br label %_D3std5array__T8AppenderTAyaZQo7opSliceMNgFNaNbNdNiNeZQBd.exit

_D3std5array__T8AppenderTAyaZQo7opSliceMNgFNaNbNdNiNeZQBd.exit: ; preds = %0, %condtrue.i
  %condtmp.0.sroa.phi14.sroa.speculated.i = phi i64 [ %.len.i, %condtrue.i ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %condtmp.0.sroa.phi17.sroa.speculated.i = phi i8* [ %.ptr.i, %condtrue.i ], [ null, %0 ] ; [#uses = 1, type = i8*]
  %.fca.0.insert7.i = insertvalue { i64, i8* } undef, i64 %condtmp.0.sroa.phi14.sroa.speculated.i, 0 ; [#uses = 1]
  %.fca.1.insert10.i = insertvalue { i64, i8* } %.fca.0.insert7.i, i8* %condtmp.0.sroa.phi17.sroa.speculated.i, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert10.i
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.array.Appender!string.Appender"* @_D3std5array__T8AppenderTAyaZQo6__ctorMFNaNbNcNeQxZSQByQBx__TQBuTQBoZQCc(%"std.array.Appender!string.Appender"* nonnull returned %.this_arg, { i64, i8* } %arr_arg) local_unnamed_addr #0 {
  %arr_arg.fca.0.extract = extractvalue { i64, i8* } %arr_arg, 0 ; [#uses = 2]
  %arr_arg.fca.1.extract = extractvalue { i64, i8* } %arr_arg, 1 ; [#uses = 1]
  %.gc_struct = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D44TypeInfo_S3std5array__T8AppenderTAyaZQo4Data6__initZ to %object.TypeInfo*)) #4 ; [#uses = 5]
  %1 = bitcast i8* %.gc_struct to i64*            ; [#uses = 1]
  %2 = getelementptr inbounds i8, i8* %.gc_struct, i64 8 ; [#uses = 1, type = i8*]
  %.repack = bitcast i8* %2 to i64*               ; [#uses = 1]
  %.repack4 = getelementptr inbounds i8, i8* %.gc_struct, i64 16 ; [#uses = 1, type = i8*]
  %3 = bitcast i8* %.repack4 to i8**              ; [#uses = 1]
  %4 = bitcast %"std.array.Appender!string.Appender"* %.this_arg to i8** ; [#uses = 1]
  %5 = getelementptr inbounds i8, i8* %.gc_struct, i64 24 ; [#uses = 1, type = i8*]
  %6 = bitcast i8* %5 to i64*                     ; [#uses = 1]
  store i64 0, i64* %6, align 8
  store i8* %.gc_struct, i8** %4, align 8
  store i64 %arr_arg.fca.0.extract, i64* %.repack, align 8
  store i8* %arr_arg.fca.1.extract, i8** %3, align 8
  store i64 %arr_arg.fca.0.extract, i64* %1, align 8
  ret %"std.array.Appender!string.Appender"* %.this_arg
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5array__T8AppenderTAyaZQo4Data11__xopEqualsFKxSQBzQBy__TQBvTQBpZQCdQBqKxQBaZb(%"std.array.Appender!string.Appender.Data"* dereferenceable(32) %q, %"std.array.Appender!string.Appender.Data"* dereferenceable(32) %p) #0 {
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %2 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %q, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %3 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %4 = load i64, i64* %2, align 8                 ; [#uses = 1]
  %5 = icmp eq i64 %3, %4                         ; [#uses = 1]
  br i1 %5, label %andand, label %andandend2

andand:                                           ; preds = %0
  %.elt = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt4 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack5 = load i8*, i8** %.elt4, align 8      ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack5, 1 ; [#uses = 1]
  %.elt6 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %q, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack7 = load i64, i64* %.elt6, align 8      ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.unpack7, 0 ; [#uses = 1]
  %.elt8 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %q, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack9 = load i8*, i8** %.elt8, align 8      ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack9, 1 ; [#uses = 1]
  %10 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %9, { i64, i8* } %7) #0 ; [#uses = 1]
  br i1 %10, label %andand1, label %andandend2

andand1:                                          ; preds = %andand
  %11 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %12 = load i8, i8* %11, align 1, !range !19     ; [#uses = 1]
  %13 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %q, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %14 = load i8, i8* %13, align 1, !range !19     ; [#uses = 1]
  %15 = icmp eq i8 %12, %14                       ; [#uses = 1]
  br label %andandend2

andandend2:                                       ; preds = %0, %andand1, %andand
  %andandval3 = phi i1 [ false, %andand ], [ %15, %andand1 ], [ false, %0 ] ; [#uses = 1, type = i1]
  ret i1 %andandval3
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T8AppenderTAyaZQo4Data9__xtoHashFNbNeKxSQCaQBz__TQBwTQBqZQCeQBrZm(%"std.array.Appender!string.Appender.Data"* dereferenceable(32) %p) #0 {
unrolledstmt:
  %0 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D11TypeInfo_xm6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl" = getelementptr inbounds [19 x i8*], [19 x i8*]* %0, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %1 = bitcast i8** %"getHash@vtbl" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %2 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %1, align 8 ; [#uses = 1]
  %3 = bitcast %"std.array.Appender!string.Appender.Data"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D11TypeInfo_xm6__initZ, i8* nonnull %3) ; [#uses = 1]
  %5 = mul i64 %4, 33                             ; [#uses = 1]
  %6 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D12TypeInfo_xAa6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl3" = getelementptr inbounds [19 x i8*], [19 x i8*]* %6, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %7 = bitcast i8** %"getHash@vtbl3" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %8 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %7, align 8 ; [#uses = 1]
  %9 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 1 ; [#uses = 1, type = { i64, i8* }*]
  %10 = bitcast { i64, i8* }* %9 to i8*           ; [#uses = 1]
  %11 = tail call i64 %8(%object.TypeInfo_Const* nonnull @_D12TypeInfo_xAa6__initZ, i8* nonnull %10) ; [#uses = 1]
  %12 = add i64 %11, %5                           ; [#uses = 1]
  %13 = mul i64 %12, 33                           ; [#uses = 1]
  %14 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D11TypeInfo_xb6__initZ, i64 0, i32 0), align 8 ; [#uses = 1]
  %"getHash@vtbl5" = getelementptr inbounds [19 x i8*], [19 x i8*]* %14, i64 0, i64 5 ; [#uses = 1, type = i8**]
  %15 = bitcast i8** %"getHash@vtbl5" to i64 (%object.TypeInfo_Const*, i8*)** ; [#uses = 1]
  %16 = load i64 (%object.TypeInfo_Const*, i8*)*, i64 (%object.TypeInfo_Const*, i8*)** %15, align 8 ; [#uses = 1]
  %17 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %p, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %18 = tail call i64 %16(%object.TypeInfo_Const* nonnull @_D11TypeInfo_xb6__initZ, i8* nonnull %17) ; [#uses = 1]
  %19 = add i64 %18, %13                          ; [#uses = 1]
  ret i64 %19
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, i64 %nelems_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.ensureAddable.0, align 8 ; [#uses = 10, size/byte = 64]
  %.sret_tmp = alloca %core.memory.BlkInfo_, align 8 ; [#uses = 2, size/byte = 24]
  %this = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!string.Appender"**]
  store %"std.array.Appender!string.Appender"* %.this_arg, %"std.array.Appender!string.Appender"** %this, align 8
  %nelems = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 1 ; [#uses = 1, type = i64*]
  store i64 %nelems_arg, i64* %nelems, align 8
  %newlen = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 2 ; [#uses = 2, type = i64*]
  %len = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 3 ; [#uses = 3, type = i64*]
  %nbytes = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 4 ; [#uses = 1, type = i64*]
  %bi = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 5 ; [#uses = 1, type = %core.memory.BlkInfo_*]
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 6, type = %"std.array.Appender!string.Appender.Data"**]
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %if, label %endif

if:                                               ; preds = %0
  %.gc_struct = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D44TypeInfo_S3std5array__T8AppenderTAyaZQo4Data6__initZ to %object.TypeInfo*)) #4 ; [#uses = 3]
  %3 = bitcast %"std.array.Appender!string.Appender"* %.this_arg to i8** ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %.gc_struct, i8 0, i64 32, i1 false)
  store i8* %.gc_struct, i8** %3, align 8
  %4 = bitcast i8* %.gc_struct to %"std.array.Appender!string.Appender.Data"* ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %if, %0
  %5 = phi %"std.array.Appender!string.Appender.Data"* [ %4, %if ], [ %2, %0 ] ; [#uses = 2, type = %"std.array.Appender!string.Appender.Data"*]
  %6 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %5, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %6, align 8              ; [#uses = 2]
  store i64 %.len, i64* %len, align 8
  %7 = add i64 %.len, %nelems_arg                 ; [#uses = 2]
  %8 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %5, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %9 = load i64, i64* %8, align 8                 ; [#uses = 2]
  %.not30 = icmp ult i64 %9, %7                   ; [#uses = 1]
  br i1 %.not30, label %endif4, label %if3

if3:                                              ; preds = %endif
  ret void

endif4:                                           ; preds = %endif
  %10 = tail call i64 @_D3std5array__T19appenderNewCapacityVmi1ZQBaFNaNbNiNfmmZm(i64 %7, i64 %9) #2 ; [#uses = 2]
  store i64 %10, i64* %newlen, align 8
  %11 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 1]
  %12 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %11, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %12, align 1, !range !19     ; [#uses = 1]
  %.not31 = icmp eq i8 %13, 0                     ; [#uses = 1]
  %.pre40 = bitcast %nest.ensureAddable.0* %.frame to i8* ; [#uses = 2]
  br i1 %.not31, label %endif6, label %if5

if5:                                              ; preds = %endif4
  %14 = call i64 @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFmZ9__lambda5MFNaNbNeZm(i8* nonnull %.pre40) ; [#uses = 2]
  %.not34 = icmp eq i64 %14, 0                    ; [#uses = 1]
  br i1 %.not34, label %if5.endif6_crit_edge, label %if7

if5.endif6_crit_edge:                             ; preds = %if5
  %.pre = load i64, i64* %newlen, align 8         ; [#uses = 1]
  br label %endif6

if7:                                              ; preds = %if5
  %15 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 1]
  %16 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %15, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %14, i64* %16, align 8
  ret void

endif6:                                           ; preds = %endif4, %if5.endif6_crit_edge
  %17 = phi i64 [ %.pre, %if5.endif6_crit_edge ], [ %10, %endif4 ] ; [#uses = 1, type = i64]
  store i64 %17, i64* %nbytes, align 8
  call void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFmZ9__lambda9MFNaNbNeZS4core6memory8BlkInfo_(%core.memory.BlkInfo_* noalias nonnull sret align 8 %.sret_tmp, i8* nonnull %.pre40)
  %18 = bitcast %core.memory.BlkInfo_* %bi to i8* ; [#uses = 1]
  %19 = bitcast %core.memory.BlkInfo_* %.sret_tmp to i8* ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(24) %18, i8* nonnull align 8 dereferenceable(24) %19, i64 24, i1 false)
  %20 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 1]
  %21 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %20, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %22 = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 5, i32 1 ; [#uses = 1, type = i64*]
  %23 = load i64, i64* %22, align 8               ; [#uses = 1]
  store i64 %23, i64* %21, align 8
  %24 = load i64, i64* %len, align 8              ; [#uses = 2]
  %.not33 = icmp eq i64 %24, 0                    ; [#uses = 1]
  br i1 %.not33, label %endif16, label %if15

if15:                                             ; preds = %endif6
  %25 = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 5, i32 0 ; [#uses = 1, type = i8**]
  %26 = load i8*, i8** %25, align 8               ; [#uses = 1]
  %27 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  %28 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %27, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %29 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %28, align 8 ; [#uses = 1]
  %30 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %29, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr.i = load i8*, i8** %30, align 8           ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %26, i8* align 1 %.ptr.i, i64 %24, i1 false) #2
  %.pre39 = load i64, i64* %len, align 8          ; [#uses = 1]
  br label %endif16

endif16:                                          ; preds = %endif6, %if15
  %31 = phi i64 [ 0, %endif6 ], [ %.pre39, %if15 ] ; [#uses = 1, type = i64]
  %32 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 2]
  %33 = getelementptr inbounds %nest.ensureAddable.0, %nest.ensureAddable.0* %.frame, i64 0, i32 5, i32 0 ; [#uses = 1, type = i8**]
  %34 = bitcast i8** %33 to i64*                  ; [#uses = 1]
  %35 = load i64, i64* %34, align 8               ; [#uses = 1]
  %36 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %32, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %31, i64* %36, align 8
  %37 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %32, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %38 = bitcast i8** %37 to i64*                  ; [#uses = 1]
  store i64 %35, i64* %38, align 8
  %39 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 1]
  %40 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %39, i64 0, i32 2 ; [#uses = 1, type = i8*]
  store i8 1, i8* %40, align 1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T8AppenderTAyaZQo8capacityMxFNaNbNdNiNfZm(%"std.array.Appender!string.Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 2]
  %.not = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %condend, label %condtrue

condtrue:                                         ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %condtmp.0.sroa.speculate.load.condtrue = load i64, i64* %3, align 8 ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %condtmp.0.sroa.speculated = phi i64 [ %condtmp.0.sroa.speculate.load.condtrue, %condtrue ], [ 0, %0 ] ; [#uses = 1, type = i64]
  ret i64 %condtmp.0.sroa.speculated
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T8AppenderTAyaZQo7opSliceMNgFNaNbNdNiNeZQBd(%"std.array.Appender!string.Appender"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %2 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %1, align 8 ; [#uses = 3]
  %.not = icmp eq %"std.array.Appender!string.Appender.Data"* %2, null ; [#uses = 1]
  br i1 %.not, label %condend, label %condtrue

condtrue:                                         ; preds = %0
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  %4 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %2, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %4, align 8              ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %condtmp.0.sroa.phi14.sroa.speculated = phi i64 [ %.len, %condtrue ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %condtmp.0.sroa.phi17.sroa.speculated = phi i8* [ %.ptr, %condtrue ], [ null, %0 ] ; [#uses = 1, type = i8*]
  %.fca.0.insert7 = insertvalue { i64, i8* } undef, i64 %condtmp.0.sroa.phi14.sroa.speculated, 0 ; [#uses = 1]
  %.fca.1.insert10 = insertvalue { i64, i8* } %.fca.0.insert7, i8* %condtmp.0.sroa.phi17.sroa.speculated, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert10
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T19appenderNewCapacityVmi1ZQBaFNaNbNiNfmmZm(i64 %reqLen_arg, i64 %curLen_arg) local_unnamed_addr #0 {
  %1 = icmp eq i64 %curLen_arg, 0                 ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %0
  %2 = icmp ugt i64 %reqLen_arg, 8                ; [#uses = 1]
  %spec.select.i = select i1 %2, i64 %reqLen_arg, i64 8 ; [#uses = 1]
  ret i64 %spec.select.i

endif:                                            ; preds = %0
  %3 = tail call i64 @llvm.ctlz.i64(i64 %curLen_arg, i1 immarg true) #10, !range !20 ; [#uses = 1]
  %4 = trunc i64 %3 to i16                        ; [#uses = 1]
  %.rhs.trunc = sub nuw nsw i16 64, %4            ; [#uses = 1]
  %5 = udiv i16 1000, %.rhs.trunc                 ; [#uses = 1]
  %.zext = zext i16 %5 to i64                     ; [#uses = 2]
  %6 = icmp ult i64 %.zext, 100                   ; [#uses = 1]
  %7 = select i1 %6, i64 %.zext, i64 100          ; [#uses = 1]
  %spec.store.select = add nuw nsw i64 %7, 100    ; [#uses = 1]
  %8 = mul i64 %spec.store.select, %curLen_arg    ; [#uses = 1]
  %9 = add i64 %8, 99                             ; [#uses = 1]
  %10 = udiv i64 %9, 100                          ; [#uses = 2]
  %11 = icmp ugt i64 %10, %reqLen_arg             ; [#uses = 1]
  %b_arg.a_arg.i = select i1 %11, i64 %10, i64 %reqLen_arg ; [#uses = 1]
  ret i64 %b_arg.a_arg.i
}

; [#uses = 1]
; Function Attrs: uwtable
define linkonce_odr i64 @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFmZ9__lambda5MFNaNbNeZm(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %this = bitcast i8* %.nest_arg to %"std.array.Appender!string.Appender"** ; [#uses = 1]
  %1 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  %2 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %1, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %3 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %2, align 8 ; [#uses = 1]
  %4 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %3, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %4, align 8              ; [#uses = 1]
  %nelems = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %5 = bitcast i8* %nelems to i64*                ; [#uses = 1]
  %6 = load i64, i64* %5, align 8                 ; [#uses = 1]
  %newlen = getelementptr inbounds i8, i8* %.nest_arg, i64 16 ; [#uses = 1, type = i8*]
  %7 = bitcast i8* %newlen to i64*                ; [#uses = 1]
  %8 = load i64, i64* %7, align 8                 ; [#uses = 1]
  %len = getelementptr inbounds i8, i8* %.nest_arg, i64 24 ; [#uses = 1, type = i8*]
  %9 = bitcast i8* %len to i64*                   ; [#uses = 1]
  %10 = load i64, i64* %9, align 8                ; [#uses = 1]
  %11 = sub i64 %8, %10                           ; [#uses = 1]
  %12 = tail call i64 @gc_extend(i8* %.ptr, i64 %6, i64 %11, %object.TypeInfo* null) #2 ; [#uses = 1]
  ret i64 %12
}

; [#uses = 1]
; Function Attrs: uwtable
define linkonce_odr void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFmZ9__lambda9MFNaNbNeZS4core6memory8BlkInfo_(%core.memory.BlkInfo_* noalias sret align 8 %.sret_arg, i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %nbytes = getelementptr inbounds i8, i8* %.nest_arg, i64 32 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %nbytes to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  tail call void @gc_qalloc(%core.memory.BlkInfo_* noalias sret align 8 %.sret_arg, i64 %2, i32 2, %object.TypeInfo* null) #2
  ret void
}

; [#uses = 1]
; Function Attrs: noinline uwtable
define weak_odr i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAaTaZ18_d_arraysetlengthTFNaNbNeMNkKQBkmZm(i64 %newlength_arg, { i64, i8* }* dereferenceable(16) %arr) local_unnamed_addr #8 {
  %1 = tail call { i64, i8* } @_d_arraysetlengthiT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Aa6__initZ to %object.TypeInfo*), i64 %newlength_arg, { i64, i8* }* nonnull %arr) #2 ; [#uses = 0]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %arr, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %2, align 8              ; [#uses = 1]
  ret i64 %.len
}

; [#uses = 1]
declare { i64, i8* } @_d_arraysetlengthiT(%object.TypeInfo*, i64, { i64, i8* }*) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: noinline uwtable
define weak_odr i64 @_D4core8internal5array5utils__T16_d_HookTraceImplTAaS_DQCbQBzQBt8capacity__T22_d_arraysetlengthTImplHTQCaTaZ18_d_arraysetlengthTFNaNbNeMNkKQDlmZmVAyaa79_43616e6e6f7420726573697a652061727261797320696620636f6d70696c696e6720776974686f757420737570706f727420666f722072756e74696d65207479706520696e666f726d6174696f6e21ZQKvFNaNbNeQGuiQGyMNkKQKxmZm(i64 %_param_4_arg, { i64, i8* }* dereferenceable(16) %_param_3, { i64, i8* } %funcname_arg, i32 %line_arg, { i64, i8* }* byval align 8 %file) local_unnamed_addr #8 {
finally:
  %.sret_tmp = alloca %core.memory.GC.Stats, align 8 ; [#uses = 2, size/byte = 24]
  %.sret_tmp1 = alloca %core.memory.GC.Stats, align 8 ; [#uses = 2, size/byte = 24]
  call void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias nonnull sret align 8 %.sret_tmp) #2
  %0 = getelementptr inbounds %core.memory.GC.Stats, %core.memory.GC.Stats* %.sret_tmp, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %1 = load i64, i64* %0, align 8                 ; [#uses = 1]
  %2 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAaTaZ18_d_arraysetlengthTFNaNbNeMNkKQBkmZm(i64 %_param_4_arg, { i64, i8* }* nonnull dereferenceable(16) %_param_3) #8 ; [#uses = 1]
  call void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias nonnull sret align 8 %.sret_tmp1) #2
  %3 = getelementptr inbounds %core.memory.GC.Stats, %core.memory.GC.Stats* %.sret_tmp1, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %4 = load i64, i64* %3, align 8                 ; [#uses = 1]
  %5 = sub i64 %4, %1                             ; [#uses = 2]
  %.not = icmp eq i64 %5, 0                       ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %finally
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %file, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %file, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack8 = load i8*, i8** %.elt7, align 8      ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack8, 1 ; [#uses = 1]
  %8 = call i64 @_D4core8internal5array5utils14accumulatePureFNaNbAyaiQeQgmZm(i64 %5, { i64, i8* } { i64 6, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.26, i32 0, i32 0) }, { i64, i8* } %funcname_arg, i32 %line_arg, { i64, i8* } %7) #2 ; [#uses = 1]
  %.not9 = icmp eq i64 %8, 0                      ; [#uses = 1]
  br i1 %.not9, label %assertFailed, label %endif

assertFailed:                                     ; preds = %if
  call void @_d_assert({ i64, i8* } { i64 67, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i32 0, i32 0) }, i32 86) #6
  unreachable

endif:                                            ; preds = %finally, %if
  ret i64 %2
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG4awZm(i32 %c_arg, [4 x i8]* dereferenceable(4) %buf) local_unnamed_addr #0 {
  %1 = bitcast [4 x i8]* %buf to i32*             ; [#uses = 1]
  store i32 -1, i32* %1, align 1
  %2 = icmp ult i32 %c_arg, 128                   ; [#uses = 1]
  br i1 %2, label %if, label %endif

if:                                               ; preds = %0
  %3 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c_arg) #2 ; [#uses = 1]
  br i1 %3, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %if
  %4 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %5 = trunc i32 %c_arg to i8                     ; [#uses = 1]
  store i8 %5, i8* %4, align 1
  ret i64 1

assertFailed:                                     ; preds = %if
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2318) #6
  unreachable

endif:                                            ; preds = %0
  %6 = icmp ult i32 %c_arg, 2048                  ; [#uses = 1]
  br i1 %6, label %if1, label %endif2

if1:                                              ; preds = %endif
  %7 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c_arg) #2 ; [#uses = 1]
  br i1 %7, label %assertPassed3, label %assertFailed4

assertPassed3:                                    ; preds = %if1
  %8 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %9 = lshr i32 %c_arg, 6                         ; [#uses = 1]
  %10 = trunc i32 %9 to i8                        ; [#uses = 1]
  %11 = or i8 %10, -64                            ; [#uses = 1]
  store i8 %11, i8* %8, align 1
  %12 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 1 ; [#uses = 1, type = i8*]
  %13 = trunc i32 %c_arg to i8                    ; [#uses = 1]
  %14 = and i8 %13, 63                            ; [#uses = 1]
  %15 = or i8 %14, -128                           ; [#uses = 1]
  store i8 %15, i8* %12, align 1
  ret i64 2

assertFailed4:                                    ; preds = %if1
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2324) #6
  unreachable

endif2:                                           ; preds = %endif
  %16 = icmp ult i32 %c_arg, 65536                ; [#uses = 1]
  br i1 %16, label %if6, label %endif7

if6:                                              ; preds = %endif2
  %17 = and i32 %c_arg, -2048                     ; [#uses = 1]
  %18 = icmp eq i32 %17, 55296                    ; [#uses = 1]
  br i1 %18, label %if8, label %endif9

if8:                                              ; preds = %if6
  %19 = tail call i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } { i64 40, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.27, i32 0, i32 0) }) #2 ; [#uses = 1]
  br label %endif9

endif9:                                           ; preds = %if8, %if6
  %c.0 = phi i32 [ %19, %if8 ], [ %c_arg, %if6 ]  ; [#uses = 2, type = i32]
  %20 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c.0) #2 ; [#uses = 1]
  br i1 %20, label %label.L3, label %assertFailed11

label.L3:                                         ; preds = %endif9, %assertPassed18
  %c.1 = phi i32 [ %c.0, %endif9 ], [ %54, %assertPassed18 ] ; [#uses = 3, type = i32]
  %21 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %22 = lshr i32 %c.1, 12                         ; [#uses = 1]
  %23 = trunc i32 %22 to i8                       ; [#uses = 1]
  %24 = or i8 %23, -32                            ; [#uses = 1]
  store i8 %24, i8* %21, align 1
  %25 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 1 ; [#uses = 1, type = i8*]
  %26 = lshr i32 %c.1, 6                          ; [#uses = 1]
  %27 = trunc i32 %26 to i8                       ; [#uses = 1]
  %28 = and i8 %27, 63                            ; [#uses = 1]
  %29 = or i8 %28, -128                           ; [#uses = 1]
  store i8 %29, i8* %25, align 1
  %30 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 2 ; [#uses = 1, type = i8*]
  %31 = trunc i32 %c.1 to i8                      ; [#uses = 1]
  %32 = and i8 %31, 63                            ; [#uses = 1]
  %33 = or i8 %32, -128                           ; [#uses = 1]
  store i8 %33, i8* %30, align 1
  ret i64 3

assertFailed11:                                   ; preds = %endif9
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2334) #6
  unreachable

endif7:                                           ; preds = %endif2
  %34 = icmp ult i32 %c_arg, 1114112              ; [#uses = 1]
  %35 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c_arg) #2 ; [#uses = 2]
  br i1 %34, label %if13, label %endif14

if13:                                             ; preds = %endif7
  br i1 %35, label %assertPassed15, label %assertFailed16

assertPassed15:                                   ; preds = %if13
  %36 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %37 = lshr i32 %c_arg, 18                       ; [#uses = 1]
  %38 = trunc i32 %37 to i8                       ; [#uses = 1]
  %39 = or i8 %38, -16                            ; [#uses = 1]
  store i8 %39, i8* %36, align 1
  %40 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 1 ; [#uses = 1, type = i8*]
  %41 = lshr i32 %c_arg, 12                       ; [#uses = 1]
  %42 = trunc i32 %41 to i8                       ; [#uses = 1]
  %43 = and i8 %42, 63                            ; [#uses = 1]
  %44 = or i8 %43, -128                           ; [#uses = 1]
  store i8 %44, i8* %40, align 1
  %45 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 2 ; [#uses = 1, type = i8*]
  %46 = lshr i32 %c_arg, 6                        ; [#uses = 1]
  %47 = trunc i32 %46 to i8                       ; [#uses = 1]
  %48 = and i8 %47, 63                            ; [#uses = 1]
  %49 = or i8 %48, -128                           ; [#uses = 1]
  store i8 %49, i8* %45, align 1
  %50 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i64 0, i64 3 ; [#uses = 1, type = i8*]
  %51 = trunc i32 %c_arg to i8                    ; [#uses = 1]
  %52 = and i8 %51, 63                            ; [#uses = 1]
  %53 = or i8 %52, -128                           ; [#uses = 1]
  store i8 %53, i8* %50, align 1
  ret i64 4

assertFailed16:                                   ; preds = %if13
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2343) #6
  unreachable

endif14:                                          ; preds = %endif7
  br i1 %35, label %assertFailed19, label %assertPassed18

assertPassed18:                                   ; preds = %endif14
  %54 = tail call i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } { i64 39, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.28, i32 0, i32 0) }) #2 ; [#uses = 1]
  br label %label.L3

assertFailed19:                                   ; preds = %endif14
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2351) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAyaZQo__T3putTAaZQiMFNaNbNfQnZv(%"std.array.Appender!string.Appender"* nonnull %.this_arg, { i64, i8* } %items_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.put.1, align 8           ; [#uses = 2, size/byte = 8]
  %items_arg.fca.0.extract = extractvalue { i64, i8* } %items_arg, 0 ; [#uses = 2]
  %this = getelementptr inbounds %nest.put.1, %nest.put.1* %.frame, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender"**]
  store %"std.array.Appender!string.Appender"* %.this_arg, %"std.array.Appender!string.Appender"** %this, align 8
  %1 = bitcast %nest.put.1* %.frame to i8*        ; [#uses = 1]
  %2 = call { i64, i8* } @_D3std5array__T8AppenderTAyaZQo__T3putTAaZQiMFQhZ10bigDataFunMFNaNbNfmZQBg(i8* nonnull %1, i64 %items_arg.fca.0.extract) #0 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %2, 1         ; [#uses = 2]
  %.len1 = extractvalue { i64, i8* } %2, 0        ; [#uses = 5]
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %.this_arg, i64 0, i32 0 ; [#uses = 2, type = %"std.array.Appender!string.Appender.Data"**]
  %4 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 1]
  %5 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2 = load i64, i64* %5, align 8             ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len1, %.len2 ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %items_arg.fca.1.extract = extractvalue { i64, i8* } %items_arg, 1 ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %.len2 ; [#uses = 1, type = i8*]
  %6 = sub i64 %.len1, %.len2                     ; [#uses = 1]
  call void @_d_array_slice_copy(i8* nocapture %lowerbound, i64 %6, i8* nocapture %items_arg.fca.1.extract, i64 %items_arg.fca.0.extract, i64 1) #4
  %7 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 2]
  %8 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %7, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len1, i64* %8, align 8
  %9 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %7, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr, i8** %9, align 8
  ret void

bounds.fail:                                      ; preds = %0
  call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 3571, i64 %.len2, i64 %.len1, i64 %.len1) #6
  unreachable
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } %msg_arg) local_unnamed_addr #0 {
  %.lval_copy_for_ImplicitByvalRewrite = alloca { i64, i8* }, align 8 ; [#uses = 3, size/byte = 16]
  %arrayliteral = alloca [1 x i32], align 4       ; [#uses = 1, size/byte = 4]
  %msg_arg.fca.0.extract = extractvalue { i64, i8* } %msg_arg, 0 ; [#uses = 1]
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 1]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #4 ; [#uses = 4]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.utf.UTFException* ; [#uses = 2]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl, align 8
  %1 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %1, align 8
  %2 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %3 = bitcast %object.Object* %2 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %3, i8* nonnull align 8 dereferenceable(96) bitcast ({ i64, i8* }* getelementptr inbounds (%std.utf.UTFException, %std.utf.UTFException* @_D3std3utf12UTFException6__initZ, i64 0, i32 2) to i8*), i64 96, i1 false)
  %msg.sroa.0.0..sroa_idx = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %msg_arg.fca.0.extract, i64* %msg.sroa.0.0..sroa_idx, align 8
  %msg.sroa.2.0..sroa_idx1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %msg_arg.fca.1.extract, i8** %msg.sroa.2.0..sroa_idx1, align 8
  %4 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCnQCmQCl(%std.utf.UTFException* nonnull returned %.newclass_gc, %object.Throwable* null, i64 2301, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #2 ; [#uses = 0]
  %5 = load [11 x i8*]*, [11 x i8*]** %vtbl, align 8 ; [#uses = 1]
  %"setSequence@vtbl" = getelementptr inbounds [11 x i8*], [11 x i8*]* %5, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %"setSequence@vtbl" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %7 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %6, align 8 ; [#uses = 1]
  %8 = getelementptr inbounds [1 x i32], [1 x i32]* %arrayliteral, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 %c_arg, i32* %8, align 4
  %9 = insertvalue { i64, i32* } { i64 1, i32* undef }, i32* %8, 1 ; [#uses = 1]
  %10 = call %std.utf.UTFException* %7(%std.utf.UTFException* nonnull %.newclass_gc, { i64, i32* } %9) ; [#uses = 1]
  %11 = bitcast %std.utf.UTFException* %10 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %11) #6
  unreachable
}

; [#uses = 1]
declare %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCnQCmQCl(%std.utf.UTFException* nonnull returned, %object.Throwable*, i64, { i64, i8* }, { i64, i8* }* byval align 8) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAaZQkFNaNbNdNiNfMKQsZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  ret i1 %.not
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T8AppenderTAyaZQo__T3putTAaZQiMFQhZ10bigDataFunMFNaNbNfmZQBg(i8* nonnull %.nest_arg, i64 %extra_arg) local_unnamed_addr #0 {
  %this = bitcast i8* %.nest_arg to %"std.array.Appender!string.Appender"** ; [#uses = 2]
  %1 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  tail call void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %1, i64 %extra_arg) #0
  %2 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %2, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %4 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 2]
  %5 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr.i = load i8*, i8** %5, align 8            ; [#uses = 1]
  %6 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %6, align 8            ; [#uses = 1]
  %7 = add i64 %.len.i, %extra_arg                ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %7, 0  ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.ptr.i, 1 ; [#uses = 1]
  ret { i64, i8* } %9
}

; [#uses = 2]
; Function Attrs: uwtable
declare void @_d_array_slice_copy(i8* nocapture, i64, i8* nocapture, i64, i64) local_unnamed_addr #4

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T8AppenderTAyaZQo__T3putTQoZQiMFQvZ10bigDataFunMFNaNbNfmZAa(i8* nonnull %.nest_arg, i64 %extra_arg) local_unnamed_addr #0 {
  %this = bitcast i8* %.nest_arg to %"std.array.Appender!string.Appender"** ; [#uses = 2]
  %1 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  tail call void @_D3std5array__T8AppenderTAyaZQo13ensureAddableMFNaNbNfmZv(%"std.array.Appender!string.Appender"* nonnull %1, i64 %extra_arg) #0
  %2 = load %"std.array.Appender!string.Appender"*, %"std.array.Appender!string.Appender"** %this, align 8 ; [#uses = 1]
  %3 = getelementptr inbounds %"std.array.Appender!string.Appender", %"std.array.Appender!string.Appender"* %2, i64 0, i32 0 ; [#uses = 1, type = %"std.array.Appender!string.Appender.Data"**]
  %4 = load %"std.array.Appender!string.Appender.Data"*, %"std.array.Appender!string.Appender.Data"** %3, align 8 ; [#uses = 2]
  %5 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.ptr.i = load i8*, i8** %5, align 8            ; [#uses = 1]
  %6 = getelementptr inbounds %"std.array.Appender!string.Appender.Data", %"std.array.Appender!string.Appender.Data"* %4, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %6, align 8            ; [#uses = 1]
  %7 = add i64 %.len.i, %extra_arg                ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %7, 0  ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.ptr.i, 1 ; [#uses = 1]
  ret { i64, i8* } %9
}

; [#uses = 5]
; Function Attrs: nounwind uwtable
declare %object.Throwable* @_d_eh_enter_catch(i8*) local_unnamed_addr #11

; [#uses = 7]
; Function Attrs: uwtable
declare i32 @_d_eh_personality(i32, i32, i64, i8*, i8*) #4

; [#uses = 7]
; Function Attrs: cold noreturn uwtable
declare void @_Unwind_Resume(i8*) local_unnamed_addr #6

; [#uses = 5]
; Function Attrs: nounwind readnone
declare i32 @llvm.eh.typeid.for(i8*) #12

; [#uses = 0]
; Function Attrs: alwaysinline uwtable
define weak_odr { i64, i8* }* @_D4core8internal5array8equality__T2atTxAyaZQjFNaNbNcNiNeAxQtmZxQy(i64 %i_arg, { i64, { i64, i8* }* } %r_arg) local_unnamed_addr #9 {
  %r_arg.fca.1.extract = extractvalue { i64, { i64, i8* }* } %r_arg, 1 ; [#uses = 1]
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract, i64 %i_arg ; [#uses = 1, type = { i64, i8* }*]
  ret { i64, i8* }* %1
}

; [#uses = 2]
declare void @_D3std5stdio13trustedStdoutFNdNeZSQBgQBf4File(%std.stdio.File* noalias sret align 8) local_unnamed_addr #2

; [#uses = 4]
declare void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File__T5writeTiTaZQlMFNfiaZv(%std.stdio.File* nonnull %.this_arg, i8 zeroext %_param_1_arg, i32 %_param_0_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
unrolledstmt:
  %w = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 7, size/byte = 48]
  %__copytmp213 = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 3, size/byte = 48]
  call void @_D3std5stdio4File17lockingTextWriterMFNfZSQBoQBnQBk17LockingTextWriter(%std.stdio.File.LockingTextWriter* noalias nonnull sret align 8 %w, %std.stdio.File* nonnull %.this_arg) #2
  %0 = bitcast %std.stdio.File.LockingTextWriter* %__copytmp213 to i8* ; [#uses = 1]
  %1 = bitcast %std.stdio.File.LockingTextWriter* %w to i8* ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(48) %0, i8* nonnull align 8 dereferenceable(48) %1, i64 48, i1 false)
  invoke void @_D3std5stdio4File17LockingTextWriter14__aggrPostblitMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %__copytmp213) #2
          to label %postinvoke3 unwind label %landingPad2

postinvoke3:                                      ; preds = %unrolledstmt
  invoke void @_D3std4conv__T11toTextRangeTiTSQBd5stdio4File17LockingTextWriterZQBzFNfiQBqZv(%std.stdio.File.LockingTextWriter* noalias nocapture nonnull align 8 %__copytmp213, i32 %_param_0_arg) #2
          to label %unrolledstmt1 unwind label %landingPad2

catch.std.utf.UTFException:                       ; preds = %landingPad2
  %2 = call %object.Throwable* @_d_eh_enter_catch(i8* %9) ; [#uses = 1]
  %3 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, i64 0, i32 2 ; [#uses = 1, type = i16*]
  store i16 0, i16* %3, align 4
  invoke void @_d_throw_exception(%object.Throwable* %2) #6
          to label %postinvoke unwind label %landingPad

postinvoke:                                       ; preds = %catch.std.utf.UTFException
  unreachable

unrolledstmt1:                                    ; preds = %postinvoke3
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %w, i8 zeroext %_param_1_arg) #2
          to label %try.success unwind label %landingPad11

catch.std.utf.UTFException7:                      ; preds = %landingPad11
  %4 = call %object.Throwable* @_d_eh_enter_catch(i8* %14) ; [#uses = 1]
  %5 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, i64 0, i32 2 ; [#uses = 1, type = i16*]
  store i16 0, i16* %5, align 4
  invoke void @_d_throw_exception(%object.Throwable* %4) #6
          to label %postinvoke9 unwind label %landingPad

postinvoke9:                                      ; preds = %catch.std.utf.UTFException7
  unreachable

try.success:                                      ; preds = %unrolledstmt1
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #2
  ret void

landingPad:                                       ; preds = %catch.std.utf.UTFException7, %catch.std.utf.UTFException
  %6 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %7 = extractvalue { i8*, i32 } %6, 0            ; [#uses = 1]
  br label %eh.resume

eh.resume:                                        ; preds = %landingPad, %landingPad2, %landingPad11
  %eh.ptr.0.ph = phi i8* [ %14, %landingPad11 ], [ %9, %landingPad2 ], [ %7, %landingPad ] ; [#uses = 1, type = i8*]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #2
  call void @_Unwind_Resume(i8* %eh.ptr.0.ph)
  unreachable

landingPad2:                                      ; preds = %postinvoke3, %unrolledstmt
  %8 = landingpad { i8*, i32 }
          cleanup
          catch %object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ ; [#uses = 2]
  %9 = extractvalue { i8*, i32 } %8, 0            ; [#uses = 2]
  %10 = extractvalue { i8*, i32 } %8, 1           ; [#uses = 1]
  %11 = call i32 @llvm.eh.typeid.for(i8* bitcast (%object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ to i8*)) ; [#uses = 1]
  %12 = icmp eq i32 %10, %11                      ; [#uses = 1]
  br i1 %12, label %catch.std.utf.UTFException, label %eh.resume

landingPad11:                                     ; preds = %unrolledstmt1
  %13 = landingpad { i8*, i32 }
          cleanup
          catch %object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ ; [#uses = 2]
  %14 = extractvalue { i8*, i32 } %13, 0          ; [#uses = 2]
  %15 = extractvalue { i8*, i32 } %13, 1          ; [#uses = 1]
  %16 = call i32 @llvm.eh.typeid.for(i8* bitcast (%object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ to i8*)) ; [#uses = 1]
  %17 = icmp eq i32 %15, %16                      ; [#uses = 1]
  br i1 %17, label %catch.std.utf.UTFException7, label %eh.resume
}

; [#uses = 2]
declare void @_D3std5stdio4File17lockingTextWriterMFNfZSQBoQBnQBk17LockingTextWriter(%std.stdio.File.LockingTextWriter* noalias sret align 8, %std.stdio.File* nonnull) local_unnamed_addr #2

; [#uses = 8]
declare void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std4conv__T11toTextRangeTiTSQBd5stdio4File17LockingTextWriterZQBzFNfiQBqZv(%std.stdio.File.LockingTextWriter* noalias nocapture align 8 %writer, i32 %value_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %buf5 = alloca [20 x i8], align 1               ; [#uses = 1, size/byte = 20]
  %buf14 = alloca [20 x i8], align 1              ; [#uses = 1, size/byte = 20]
  %1 = icmp slt i32 %value_arg, 0                 ; [#uses = 1]
  %2 = sext i32 %value_arg to i64                 ; [#uses = 2]
  br i1 %1, label %if, label %else

if:                                               ; preds = %0
  %buf5.sub = getelementptr inbounds [20 x i8], [20 x i8]* %buf5, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %3 = insertvalue { i64, i8* } { i64 20, i8* undef }, i8* %buf5.sub, 1 ; [#uses = 1]
  %4 = call { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd({ i64, i8* } %3, i64 %2) #2 ; [#uses = 1]
  invoke void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %4, %std.stdio.File.LockingTextWriter* dereferenceable(48) %writer) #2
          to label %try.success unwind label %eh.resume

else:                                             ; preds = %0
  %buf14.sub = getelementptr inbounds [20 x i8], [20 x i8]* %buf14, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %5 = insertvalue { i64, i8* } { i64 20, i8* undef }, i8* %buf14.sub, 1 ; [#uses = 1]
  %6 = call { i64, i8* } @_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd({ i64, i8* } %5, i64 %2) #2 ; [#uses = 1]
  invoke void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %6, %std.stdio.File.LockingTextWriter* dereferenceable(48) %writer) #2
          to label %try.success unwind label %eh.resume

try.success:                                      ; preds = %else, %if
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #2
  ret void

eh.resume:                                        ; preds = %else, %if
  %7 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %8 = extractvalue { i8*, i32 } %7, 0            ; [#uses = 1]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #2
  call void @_Unwind_Resume(i8* %8)
  unreachable
}

; [#uses = 2]
declare void @_D3std5stdio4File17LockingTextWriter14__aggrPostblitMFNeZv(%std.stdio.File.LockingTextWriter* nonnull) local_unnamed_addr #2

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTaZQBqFNfKQBsaZv(i8 zeroext %e_arg, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %r, i8 zeroext %e_arg) #2
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTaZQBsFNfKQBsKaZv(i8* dereferenceable(1) %e, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  %1 = load i8, i8* %e, align 1                   ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %r, i8 zeroext %1) #2
  ret void
}

; [#uses = 5]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %c_arg) local_unnamed_addr #0 {
  %str = alloca { i64, i8* }, align 8             ; [#uses = 3, size/byte = 16]
  %wbuf = alloca [1 x i32], align 4               ; [#uses = 2, size/byte = 4]
  tail call void @_D3std5stdio4File17LockingTextWriter26highSurrogateShouldBeEmptyMFNfZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #2
  %1 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i32*]
  %2 = load i32, i32* %1, align 4                 ; [#uses = 1]
  %3 = icmp slt i32 %2, 1                         ; [#uses = 1]
  %4 = zext i8 %c_arg to i32                      ; [#uses = 2]
  br i1 %3, label %if, label %else

if:                                               ; preds = %0
  %5 = tail call %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #2 ; [#uses = 1]
  %6 = tail call i32 @fputc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %5) #2 ; [#uses = 0]
  br label %endif

else:                                             ; preds = %0
  %7 = icmp sgt i8 %c_arg, -1                     ; [#uses = 1]
  br i1 %7, label %if1, label %else3

if1:                                              ; preds = %else
  %8 = tail call %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #2 ; [#uses = 1]
  %9 = tail call i32 @fputwc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %8) #2 ; [#uses = 0]
  br label %endif

else3:                                            ; preds = %else
  %10 = icmp ugt i8 %c_arg, -65                   ; [#uses = 1]
  %11 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 3 ; [#uses = 2, type = [4 x i8]*]
  br i1 %10, label %if4, label %else6

if4:                                              ; preds = %else3
  %12 = getelementptr inbounds [4 x i8], [4 x i8]* %11, i64 0, i64 0 ; [#uses = 1, type = i8*]
  store i8 %c_arg, i8* %12, align 1
  %13 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 5 ; [#uses = 1, type = i64*]
  store i64 1, i64* %13, align 8
  br label %endif

else6:                                            ; preds = %else3
  %14 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 5 ; [#uses = 5, type = i64*]
  %15 = load i64, i64* %14, align 8               ; [#uses = 3]
  %bounds.cmp = icmp ult i64 %15, 4               ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %else6
  %16 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 3, i64 %15 ; [#uses = 1, type = i8*]
  store i8 %c_arg, i8* %16, align 1
  %17 = load i64, i64* %14, align 8               ; [#uses = 1]
  %18 = add i64 %17, 1                            ; [#uses = 1]
  store i64 %18, i64* %14, align 8
  %19 = getelementptr [4 x i8], [4 x i8]* %11, i64 0, i64 0 ; [#uses = 2, type = i8*]
  %20 = insertvalue { i64, i8* } { i64 4, i8* undef }, i8* %19, 1 ; [#uses = 1]
  %21 = tail call i32 @_D3std3utf__T6strideTAaZQlFNaNfQkZk({ i64, i8* } %20) #2 ; [#uses = 2]
  %22 = zext i32 %21 to i64                       ; [#uses = 3]
  %23 = load i64, i64* %14, align 8               ; [#uses = 1]
  %24 = icmp eq i64 %23, %22                      ; [#uses = 1]
  br i1 %24, label %if7, label %endif

if7:                                              ; preds = %bounds.ok
  %bounds.cmp.up = icmp ult i32 %21, 5            ; [#uses = 1]
  br i1 %bounds.cmp.up, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %if7
  %25 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %22, i64* %25, align 8
  %26 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %19, i8** %26, align 8
  %27 = call i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNfKQmZw({ i64, i8* }* nonnull dereferenceable(16) %str) #2 ; [#uses = 1]
  %28 = getelementptr inbounds [1 x i32], [1 x i32]* %wbuf, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 65535, i32* %28, align 4
  %29 = call i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG1wwZm(i32 %27, [1 x i32]* nonnull dereferenceable(4) %wbuf) #2 ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %bounds.ok12, %bounds.ok9
  %bounds.cmp11 = phi i1 [ false, %bounds.ok12 ], [ true, %bounds.ok9 ] ; [#uses = 1, type = i1]
  %__key209.0 = phi i64 [ 1, %bounds.ok12 ], [ 0, %bounds.ok9 ] ; [#uses = 1, type = i64]
  %30 = icmp ult i64 %__key209.0, %29             ; [#uses = 1]
  br i1 %30, label %forbody, label %endfor

forbody:                                          ; preds = %forcond
  br i1 %bounds.cmp11, label %bounds.ok12, label %bounds.fail13

bounds.ok12:                                      ; preds = %forbody
  %31 = load i32, i32* %28, align 4               ; [#uses = 1]
  %32 = call %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #2 ; [#uses = 1]
  %33 = call i32 @fputwc_unlocked(i32 %31, %core.stdc.stdio._IO_FILE* %32) #2 ; [#uses = 0]
  br label %forcond

bounds.fail13:                                    ; preds = %forbody
  call void @_d_arraybounds_index({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i32 0, i32 0) }, i32 3310, i64 1, i64 1) #6
  unreachable

endfor:                                           ; preds = %forcond
  store i64 0, i64* %14, align 8
  br label %endif

bounds.fail10:                                    ; preds = %if7
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i32 0, i32 0) }, i32 3305, i64 0, i64 %22, i64 4) #6
  unreachable

bounds.fail:                                      ; preds = %else6
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i32 0, i32 0) }, i32 3301, i64 %15, i64 4) #6
  unreachable

endif:                                            ; preds = %if1, %bounds.ok, %endfor, %if4, %if
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZ12trustedFPUTCFNbNiNeiPS4core4stdcQDe8_IO_FILEZi(%core.stdc.stdio._IO_FILE* %h_arg, i32 %ch_arg) local_unnamed_addr #0 {
  %1 = tail call i32 @fputc_unlocked(i32 %ch_arg, %core.stdc.stdio._IO_FILE* %h_arg) #2 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 2]
; Function Attrs: nofree nounwind
declare i32 @fputc_unlocked(i32, %core.stdc.stdio._IO_FILE* nocapture) local_unnamed_addr #13

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZ13trustedFPUTWCFNbNiNewPS4core4stdcQDf8_IO_FILEZw(%core.stdc.stdio._IO_FILE* %h_arg, i32 %ch_arg) local_unnamed_addr #0 {
  %1 = tail call i32 @fputwc_unlocked(i32 %ch_arg, %core.stdc.stdio._IO_FILE* %h_arg) #2 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 3]
declare i32 @fputwc_unlocked(i32, %core.stdc.stdio._IO_FILE*) local_unnamed_addr #2

; [#uses = 1]
declare void @_D3std5stdio4File17LockingTextWriter26highSurrogateShouldBeEmptyMFNfZv(%std.stdio.File.LockingTextWriter* nonnull) local_unnamed_addr #2

; [#uses = 3]
declare %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T6strideTAaZQlFNaNfQkZk({ i64, i8* } %str_arg) local_unnamed_addr #0 {
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 1]
  %bounds.cmp.not = icmp eq i64 %str_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %bounds.cmp.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 1]
  %1 = load i8, i8* %str_arg.fca.1.extract, align 1 ; [#uses = 2]
  %2 = icmp sgt i8 %1, -1                         ; [#uses = 1]
  br i1 %2, label %if, label %else

if:                                               ; preds = %bounds.ok
  ret i32 1

else:                                             ; preds = %bounds.ok
  %3 = tail call i32 @_D3std3utf10strideImplFNaNeamZk(i64 0, i8 zeroext %1) #2 ; [#uses = 1]
  ret i32 %3

bounds.fail:                                      ; preds = %0
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 403, i64 0, i64 0) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNfKQmZw({ i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #0 {
  %numCodeUnits = alloca i64, align 8             ; [#uses = 2, size/byte = 8]
  store i64 0, i64* %numCodeUnits, align 8
  %1 = call i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNeKQmJmZw(i64* nonnull dereferenceable(8) %numCodeUnits, { i64, i8* }* nonnull dereferenceable(16) %str) #2 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG1wwZm(i32 %c_arg, [1 x i32]* dereferenceable(4) %buf) local_unnamed_addr #0 {
arrayinit.cond:
  %0 = getelementptr inbounds [1 x i32], [1 x i32]* %buf, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 65535, i32* %0, align 4
  %1 = and i32 %c_arg, -2048                      ; [#uses = 1]
  %2 = icmp eq i32 %1, 55296                      ; [#uses = 1]
  %3 = icmp ugt i32 %c_arg, 1114111               ; [#uses = 1]
  %ororval = or i1 %3, %2                         ; [#uses = 1]
  br i1 %ororval, label %if, label %else

if:                                               ; preds = %arrayinit.cond
  %4 = tail call i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } { i64 40, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.29, i32 0, i32 0) }) #0 ; [#uses = 1]
  br label %endif

else:                                             ; preds = %arrayinit.cond
  %5 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c_arg) #2 ; [#uses = 1]
  br i1 %5, label %endif, label %assertFailed

assertFailed:                                     ; preds = %else
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 2506) #6
  unreachable

endif:                                            ; preds = %else, %if
  %c.0 = phi i32 [ %4, %if ], [ %c_arg, %else ]   ; [#uses = 1, type = i32]
  store i32 %c.0, i32* %0, align 4
  ret i64 1
}

; [#uses = 1]
declare i32 @_D3std3utf10strideImplFNaNeamZk(i64, i8 zeroext) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNeKQmJmZw(i64* dereferenceable(8) %numCodeUnits, { i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #0 {
  store i64 0, i64* %numCodeUnits, align 8
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 5, type = i64*]
  %.len.i = load i64, i64* %1, align 8            ; [#uses = 2]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br i1 %.not.i, label %assertFailed, label %bounds.ok

bounds.ok:                                        ; preds = %0
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 5, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 2]
  %3 = load i8, i8* %.ptr, align 1                ; [#uses = 1]
  %4 = icmp sgt i8 %3, -1                         ; [#uses = 1]
  br i1 %4, label %if, label %else

if:                                               ; preds = %bounds.ok
  store i64 1, i64* %numCodeUnits, align 8
  %.len1 = load i64, i64* %1, align 8             ; [#uses = 2]
  %bounds.cmp2.not = icmp eq i64 %.len1, 0        ; [#uses = 1]
  br i1 %bounds.cmp2.not, label %bounds.fail4, label %bounds.ok3

bounds.ok3:                                       ; preds = %if
  %.ptr5 = load i8*, i8** %2, align 8             ; [#uses = 2]
  %5 = load i8, i8* %.ptr5, align 1               ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr5, i64 1 ; [#uses = 1, type = i8*]
  %6 = add i64 %.len1, -1                         ; [#uses = 1]
  store i64 %6, i64* %1, align 8
  store i8* %lowerbound, i8** %2, align 8
  %7 = zext i8 %5 to i32                          ; [#uses = 1]
  br label %label.__returnLabel

bounds.fail4:                                     ; preds = %if
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1292, i64 0, i64 0) #6
  unreachable

else:                                             ; preds = %bounds.ok
  %8 = insertvalue { i64, i8* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.ptr, 1  ; [#uses = 1]
  %10 = tail call i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFNaQkKmZw(i64* nonnull dereferenceable(8) %numCodeUnits, { i64, i8* } %9) #2 ; [#uses = 1]
  %11 = load i64, i64* %numCodeUnits, align 8     ; [#uses = 4]
  %.len14 = load i64, i64* %1, align 8            ; [#uses = 4]
  %bounds.cmp.lo18.not = icmp ult i64 %.len14, %11 ; [#uses = 1]
  br i1 %bounds.cmp.lo18.not, label %bounds.fail16, label %bounds.ok15

bounds.ok15:                                      ; preds = %else
  %.ptr19 = load i8*, i8** %2, align 8            ; [#uses = 1]
  %lowerbound20 = getelementptr inbounds i8, i8* %.ptr19, i64 %11 ; [#uses = 1, type = i8*]
  %12 = sub i64 %.len14, %11                      ; [#uses = 1]
  store i64 %12, i64* %1, align 8
  store i8* %lowerbound20, i8** %2, align 8
  br label %label.__returnLabel

bounds.fail16:                                    ; preds = %else
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1299, i64 %11, i64 %.len14, i64 %.len14) #6
  unreachable

label.__returnLabel:                              ; preds = %bounds.ok15, %bounds.ok3
  %__result.0 = phi i32 [ %7, %bounds.ok3 ], [ %10, %bounds.ok15 ] ; [#uses = 2, type = i32]
  %13 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %__result.0) #2 ; [#uses = 1]
  br i1 %13, label %assertPassed23, label %assertFailed24

assertPassed23:                                   ; preds = %label.__returnLabel
  ret i32 %__result.0

assertFailed24:                                   ; preds = %label.__returnLabel
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1285) #6
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1281) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFNaQkKmZw(i64* dereferenceable(8) %index, { i64, i8* } %str_arg) local_unnamed_addr #0 {
  %.frame = alloca %nest.decodeImpl.4, align 8    ; [#uses = 15, size/byte = 16]
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 1]
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 1]
  %pstr = getelementptr inbounds %nest.decodeImpl.4, %nest.decodeImpl.4* %.frame, i64 0, i32 0 ; [#uses = 1, type = i8**]
  %length = getelementptr inbounds %nest.decodeImpl.4, %nest.decodeImpl.4* %.frame, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %1 = load i64, i64* %index, align 8             ; [#uses = 4]
  %2 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %1 ; [#uses = 5, type = i8*]
  store i8* %2, i8** %pstr, align 8
  %3 = sub i64 %str_arg.fca.0.extract, %1         ; [#uses = 4]
  store i64 %3, i64* %length, align 8
  %4 = load i8, i8* %2, align 1                   ; [#uses = 4]
  %5 = zext i8 %4 to i32                          ; [#uses = 3]
  %6 = and i32 %5, 192                            ; [#uses = 1]
  %.not = icmp eq i32 %6, 192                     ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %7 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %8 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %7) #0 ; [#uses = 1]
  %9 = bitcast %std.utf.UTFException* %8 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %9) #6
  unreachable

endif:                                            ; preds = %0
  %10 = icmp eq i64 %3, 1                         ; [#uses = 1]
  br i1 %10, label %if3, label %endif4

if3:                                              ; preds = %endif
  %11 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %12 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %11) #0 ; [#uses = 1]
  %13 = bitcast %std.utf.UTFException* %12 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %13) #6
  unreachable

endif4:                                           ; preds = %endif
  %14 = getelementptr inbounds i8, i8* %2, i64 1  ; [#uses = 1, type = i8*]
  %15 = load i8, i8* %14, align 1                 ; [#uses = 1]
  %16 = zext i8 %15 to i32                        ; [#uses = 2]
  %17 = and i32 %16, 192                          ; [#uses = 1]
  %.not75 = icmp eq i32 %17, 128                  ; [#uses = 1]
  br i1 %.not75, label %endif7, label %if6

if6:                                              ; preds = %endif4
  %18 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %19 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %18) #0 ; [#uses = 1]
  %20 = bitcast %std.utf.UTFException* %19 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %20) #6
  unreachable

endif7:                                           ; preds = %endif4
  %21 = shl nuw nsw i32 %5, 6                     ; [#uses = 1]
  %22 = and i32 %16, 63                           ; [#uses = 1]
  %23 = or i32 %22, %21                           ; [#uses = 4]
  %.mask79 = and i8 %4, 32                        ; [#uses = 1]
  %24 = icmp eq i8 %.mask79, 0                    ; [#uses = 1]
  br i1 %24, label %if9, label %unrolledstmt1

if9:                                              ; preds = %endif7
  %25 = and i32 %5, 30                            ; [#uses = 1]
  %26 = icmp eq i32 %25, 0                        ; [#uses = 1]
  br i1 %26, label %if11, label %endif12

if11:                                             ; preds = %if9
  %27 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %28 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %27) #0 ; [#uses = 1]
  %29 = bitcast %std.utf.UTFException* %28 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %29) #6
  unreachable

endif12:                                          ; preds = %if9
  %30 = and i32 %23, 2047                         ; [#uses = 1]
  %31 = add i64 %1, 2                             ; [#uses = 1]
  store i64 %31, i64* %index, align 8
  ret i32 %30

unrolledstmt1:                                    ; preds = %endif7
  %32 = icmp eq i64 %3, 2                         ; [#uses = 1]
  br i1 %32, label %if14, label %endif15

if14:                                             ; preds = %unrolledstmt1
  %33 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %34 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %33) #0 ; [#uses = 1]
  %35 = bitcast %std.utf.UTFException* %34 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %35) #6
  unreachable

endif15:                                          ; preds = %unrolledstmt1
  %36 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %38 = zext i8 %37 to i32                        ; [#uses = 2]
  %39 = and i32 %38, 192                          ; [#uses = 1]
  %.not76 = icmp eq i32 %39, 128                  ; [#uses = 1]
  br i1 %.not76, label %endif18, label %if17

if17:                                             ; preds = %endif15
  %40 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %41 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %40) #0 ; [#uses = 1]
  %42 = bitcast %std.utf.UTFException* %41 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %42) #6
  unreachable

endif18:                                          ; preds = %endif15
  %43 = shl nuw nsw i32 %23, 6                    ; [#uses = 1]
  %44 = and i32 %38, 63                           ; [#uses = 1]
  %45 = or i32 %44, %43                           ; [#uses = 2]
  %.mask80 = and i8 %4, 16                        ; [#uses = 1]
  %46 = icmp eq i8 %.mask80, 0                    ; [#uses = 1]
  br i1 %46, label %if20, label %unrolledstmt2

if20:                                             ; preds = %endif18
  %47 = and i32 %45, 65535                        ; [#uses = 2]
  %48 = and i32 %23, 992                          ; [#uses = 1]
  %49 = icmp eq i32 %48, 0                        ; [#uses = 1]
  br i1 %49, label %if22, label %endif23

if22:                                             ; preds = %if20
  %50 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %51 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %50) #0 ; [#uses = 1]
  %52 = bitcast %std.utf.UTFException* %51 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %52) #6
  unreachable

endif23:                                          ; preds = %if20
  %53 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %47) #2 ; [#uses = 1]
  br i1 %53, label %endif26, label %if25

if25:                                             ; preds = %endif23
  %54 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %55 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %54) #0 ; [#uses = 1]
  %56 = bitcast %std.utf.UTFException* %55 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %56) #6
  unreachable

endif26:                                          ; preds = %endif23
  %57 = load i64, i64* %index, align 8            ; [#uses = 1]
  %58 = add i64 %57, 3                            ; [#uses = 1]
  store i64 %58, i64* %index, align 8
  ret i32 %47

unrolledstmt2:                                    ; preds = %endif18
  %59 = icmp eq i64 %3, 3                         ; [#uses = 1]
  br i1 %59, label %if29, label %endif30

if29:                                             ; preds = %unrolledstmt2
  %60 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %61 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %60) #0 ; [#uses = 1]
  %62 = bitcast %std.utf.UTFException* %61 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %62) #6
  unreachable

endif30:                                          ; preds = %unrolledstmt2
  %63 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %64 = load i8, i8* %63, align 1                 ; [#uses = 1]
  %65 = zext i8 %64 to i32                        ; [#uses = 2]
  %66 = and i32 %65, 192                          ; [#uses = 1]
  %.not77 = icmp eq i32 %66, 128                  ; [#uses = 1]
  br i1 %.not77, label %endif33, label %if32

if32:                                             ; preds = %endif30
  %67 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %68 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %67) #0 ; [#uses = 1]
  %69 = bitcast %std.utf.UTFException* %68 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %69) #6
  unreachable

endif33:                                          ; preds = %endif30
  %.mask = and i8 %4, 8                           ; [#uses = 1]
  %.not78 = icmp eq i8 %.mask, 0                  ; [#uses = 1]
  br i1 %.not78, label %if35, label %unrolledend

if35:                                             ; preds = %endif33
  %70 = shl nuw nsw i32 %45, 6                    ; [#uses = 1]
  %71 = and i32 %65, 63                           ; [#uses = 1]
  %.masked = and i32 %70, 2097088                 ; [#uses = 1]
  %72 = or i32 %71, %.masked                      ; [#uses = 2]
  %73 = and i32 %23, 496                          ; [#uses = 1]
  %74 = icmp eq i32 %73, 0                        ; [#uses = 1]
  br i1 %74, label %if37, label %endif38

if37:                                             ; preds = %if35
  %75 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %76 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %75) #0 ; [#uses = 1]
  %77 = bitcast %std.utf.UTFException* %76 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %77) #6
  unreachable

endif38:                                          ; preds = %if35
  %78 = add i64 %1, 4                             ; [#uses = 1]
  store i64 %78, i64* %index, align 8
  %79 = icmp ugt i32 %72, 1114111                 ; [#uses = 1]
  br i1 %79, label %if40, label %endif41

if40:                                             ; preds = %endif38
  %80 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %81 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %80) #0 ; [#uses = 1]
  %82 = bitcast %std.utf.UTFException* %81 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %82) #6
  unreachable

endif41:                                          ; preds = %endif38
  ret i32 %72

unrolledend:                                      ; preds = %endif33
  %83 = bitcast %nest.decodeImpl.4* %.frame to i8* ; [#uses = 1]
  %84 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %83) #0 ; [#uses = 1]
  %85 = bitcast %std.utf.UTFException* %84 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %85) #6
  unreachable
}

; [#uses = 10]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } { i64 22, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } %5) #2 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } %msg_arg, { i64, i8* } %str_arg) local_unnamed_addr #0 {
bounds.ok:
  %sequence = alloca [4 x i32], align 4           ; [#uses = 5, size/byte = 16]
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 9]
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 7]
  %exitcond.not = icmp eq i64 %str_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail3, label %bounds.ok2

bounds.ok2:                                       ; preds = %bounds.ok
  %0 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %1 = load i8, i8* %str_arg.fca.1.extract, align 1 ; [#uses = 1]
  %2 = zext i8 %1 to i32                          ; [#uses = 1]
  store i32 %2, i32* %0, align 4
  %.not = icmp eq i64 %str_arg.fca.0.extract, 1   ; [#uses = 1]
  br i1 %.not, label %enddowhile, label %bounds.ok9

bounds.fail3:                                     ; preds = %bounds.ok.3, %bounds.ok.2, %bounds.ok.1, %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #6
  unreachable

bounds.ok9:                                       ; preds = %bounds.ok2
  %3 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %4 = load i8, i8* %3, align 1                   ; [#uses = 1]
  %5 = and i8 %4, -64                             ; [#uses = 1]
  %6 = icmp eq i8 %5, -128                        ; [#uses = 1]
  br i1 %6, label %bounds.ok.1, label %enddowhile

enddowhile:                                       ; preds = %bounds.ok2.3, %bounds.ok2, %bounds.ok9.2, %bounds.ok2.2, %bounds.ok9.1, %bounds.ok2.1, %bounds.ok9
  %.lcssa = phi i64 [ 1, %bounds.ok2 ], [ 1, %bounds.ok9 ], [ 2, %bounds.ok2.1 ], [ 2, %bounds.ok9.1 ], [ 3, %bounds.ok2.2 ], [ 3, %bounds.ok9.2 ], [ 4, %bounds.ok2.3 ] ; [#uses = 2, type = i64]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #4 ; [#uses = 4]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.utf.UTFException* ; [#uses = 2]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl, align 8
  %7 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %7, align 8
  %8 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %9 = bitcast %object.Object* %8 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %9, i8* nonnull align 8 dereferenceable(96) bitcast ({ i64, i8* }* getelementptr inbounds (%std.utf.UTFException, %std.utf.UTFException* @_D3std3utf12UTFException6__initZ, i64 0, i32 2) to i8*), i64 96, i1 false)
  %10 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNfAyamQemC6object9ThrowableZCQCmQClQCk(%std.utf.UTFException* nonnull returned %.newclass_gc, %object.Throwable* null, i64 1547, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.14, i32 0, i32 0) }, i64 %.lcssa, { i64, i8* } %msg_arg) #2 ; [#uses = 0]
  %11 = load [11 x i8*]*, [11 x i8*]** %vtbl, align 8 ; [#uses = 1]
  %"setSequence@vtbl" = getelementptr inbounds [11 x i8*], [11 x i8*]* %11, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %12 = bitcast i8** %"setSequence@vtbl" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %13 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %12, align 8 ; [#uses = 1]
  %14 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %15 = insertvalue { i64, i32* } undef, i64 %.lcssa, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i32* } %15, i32* %14, 1 ; [#uses = 1]
  %17 = call %std.utf.UTFException* %13(%std.utf.UTFException* nonnull %.newclass_gc, { i64, i32* } %16) ; [#uses = 1]
  ret %std.utf.UTFException* %17

bounds.ok.1:                                      ; preds = %bounds.ok9
  %exitcond.not.1 = icmp eq i64 %str_arg.fca.0.extract, 1 ; [#uses = 1]
  br i1 %exitcond.not.1, label %bounds.fail3, label %bounds.ok2.1

bounds.ok2.1:                                     ; preds = %bounds.ok.1
  %18 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 1 ; [#uses = 1, type = i32*]
  %19 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %20 = load i8, i8* %19, align 1                 ; [#uses = 1]
  %21 = zext i8 %20 to i32                        ; [#uses = 1]
  store i32 %21, i32* %18, align 4
  %22 = icmp ugt i64 %str_arg.fca.0.extract, 2    ; [#uses = 1]
  br i1 %22, label %bounds.ok9.1, label %enddowhile

bounds.ok9.1:                                     ; preds = %bounds.ok2.1
  %23 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = and i8 %24, -64                           ; [#uses = 1]
  %26 = icmp eq i8 %25, -128                      ; [#uses = 1]
  br i1 %26, label %bounds.ok.2, label %enddowhile

bounds.ok.2:                                      ; preds = %bounds.ok9.1
  %exitcond.not.2 = icmp eq i64 %str_arg.fca.0.extract, 2 ; [#uses = 1]
  br i1 %exitcond.not.2, label %bounds.fail3, label %bounds.ok2.2

bounds.ok2.2:                                     ; preds = %bounds.ok.2
  %27 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 2 ; [#uses = 1, type = i32*]
  %28 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 2 ; [#uses = 1, type = i8*]
  %29 = load i8, i8* %28, align 1                 ; [#uses = 1]
  %30 = zext i8 %29 to i32                        ; [#uses = 1]
  store i32 %30, i32* %27, align 4
  %31 = icmp ugt i64 %str_arg.fca.0.extract, 3    ; [#uses = 1]
  br i1 %31, label %bounds.ok9.2, label %enddowhile

bounds.ok9.2:                                     ; preds = %bounds.ok2.2
  %32 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 3 ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %34 = and i8 %33, -64                           ; [#uses = 1]
  %35 = icmp eq i8 %34, -128                      ; [#uses = 1]
  br i1 %35, label %bounds.ok.3, label %enddowhile

bounds.ok.3:                                      ; preds = %bounds.ok9.2
  %exitcond.not.3 = icmp eq i64 %str_arg.fca.0.extract, 3 ; [#uses = 1]
  br i1 %exitcond.not.3, label %bounds.fail3, label %bounds.ok2.3

bounds.ok2.3:                                     ; preds = %bounds.ok.3
  %36 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence, i64 0, i64 3 ; [#uses = 1, type = i32*]
  %37 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 3 ; [#uses = 1, type = i8*]
  %38 = load i8, i8* %37, align 1                 ; [#uses = 1]
  %39 = zext i8 %38 to i32                        ; [#uses = 1]
  store i32 %39, i32* %36, align 4
  br label %enddowhile
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #0 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.13, i32 0, i32 0) }, { i64, i8* } %5) #2 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

; [#uses = 4]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %e_arg, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  %e = alloca { i64, i8* }, align 8               ; [#uses = 3, size/byte = 16]
  %e_arg.fca.0.extract = extractvalue { i64, i8* } %e_arg, 0 ; [#uses = 1]
  %e_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %e_arg.fca.0.extract, i64* %e_arg.fca.0.gep, align 8
  %e_arg.fca.1.extract = extractvalue { i64, i8* } %e_arg, 1 ; [#uses = 1]
  %e_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %e_arg.fca.1.extract, i8** %e_arg.fca.1.gep, align 8
  call void @_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv({ i64, i8* }* nonnull dereferenceable(16) %e, %std.stdio.File.LockingTextWriter* nonnull dereferenceable(48) %r) #2
  ret void
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd({ i64, i8* } %buf_arg, i64 %value_arg) local_unnamed_addr #0 {
endif:
  %.frame = alloca %nest.signedToTempString, align 8 ; [#uses = 3, size/byte = 16]
  %buf_arg.fca.0.extract = extractvalue { i64, i8* } %buf_arg, 0 ; [#uses = 1]
  %buf_arg.fca.1.extract = extractvalue { i64, i8* } %buf_arg, 1 ; [#uses = 1]
  %.sroa.0.0..sroa_idx = getelementptr inbounds %nest.signedToTempString, %nest.signedToTempString* %.frame, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %buf_arg.fca.0.extract, i64* %.sroa.0.0..sroa_idx, align 8
  %.sroa.2.0..sroa_idx26 = getelementptr inbounds %nest.signedToTempString, %nest.signedToTempString* %.frame, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %buf_arg.fca.1.extract, i8** %.sroa.2.0..sroa_idx26, align 8
  %0 = icmp slt i64 %value_arg, 0                 ; [#uses = 2]
  %negval = sub i64 0, %value_arg                 ; [#uses = 1]
  %spec.select = select i1 %0, i64 %negval, i64 %value_arg ; [#uses = 1]
  %1 = tail call { i64, i8* } @_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd({ i64, i8* } %buf_arg, i64 %spec.select) #2 ; [#uses = 3]
  %.ptr = extractvalue { i64, i8* } %1, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %1, 0         ; [#uses = 1]
  br i1 %0, label %if2, label %endif3

if2:                                              ; preds = %endif
  %2 = bitcast %nest.signedToTempString* %.frame to i8* ; [#uses = 1]
  %3 = call { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh(i8* nonnull %2, { i64, i8* } %1) #0 ; [#uses = 2]
  %.ptr4 = extractvalue { i64, i8* } %3, 1        ; [#uses = 2]
  %.len5 = extractvalue { i64, i8* } %3, 0        ; [#uses = 2]
  %bounds.cmp.not = icmp eq i64 %.len5, 0         ; [#uses = 1]
  br i1 %bounds.cmp.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %if2
  store i8 45, i8* %.ptr4, align 1
  br label %endif3

bounds.fail:                                      ; preds = %if2
  call void @_d_arraybounds_index({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.30, i32 0, i32 0) }, i32 124, i64 0, i64 0) #6
  unreachable

endif3:                                           ; preds = %bounds.ok, %endif
  %r.sroa.6.0 = phi i8* [ %.ptr4, %bounds.ok ], [ %.ptr, %endif ] ; [#uses = 1, type = i8*]
  %r.sroa.0.0 = phi i64 [ %.len5, %bounds.ok ], [ %.len, %endif ] ; [#uses = 1, type = i64]
  %.fca.0.insert10 = insertvalue { i64, i8* } undef, i64 %r.sroa.0.0, 0 ; [#uses = 1]
  %.fca.1.insert19 = insertvalue { i64, i8* } %.fca.0.insert10, i8* %r.sroa.6.0, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert19
}

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd({ i64, i8* } %buf_arg, i64 %value_arg) local_unnamed_addr #0 {
  %buf_arg.fca.0.extract = extractvalue { i64, i8* } %buf_arg, 0 ; [#uses = 4]
  %buf_arg.fca.1.extract = extractvalue { i64, i8* } %buf_arg, 1 ; [#uses = 2]
  br label %dowhile

dowhile:                                          ; preds = %bounds.ok, %0
  %value.0 = phi i64 [ %value_arg, %0 ], [ %value.1, %bounds.ok ] ; [#uses = 4, type = i64]
  %i.0 = phi i64 [ %buf_arg.fca.0.extract, %0 ], [ %4, %bounds.ok ] ; [#uses = 1, type = i64]
  %1 = icmp ult i64 %value.0, 10                  ; [#uses = 1]
  br i1 %1, label %endif, label %else

else:                                             ; preds = %dowhile
  %2 = urem i64 %value.0, 10                      ; [#uses = 1]
  %3 = udiv i64 %value.0, 10                      ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %dowhile, %else
  %value.1 = phi i64 [ %3, %else ], [ 0, %dowhile ] ; [#uses = 2, type = i64]
  %x.0.in = phi i64 [ %2, %else ], [ %value.0, %dowhile ] ; [#uses = 1, type = i64]
  %4 = add i64 %i.0, -1                           ; [#uses = 6]
  %bounds.cmp = icmp ugt i64 %buf_arg.fca.0.extract, %4 ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %endif
  %x.0 = trunc i64 %x.0.in to i8                  ; [#uses = 1]
  %5 = getelementptr inbounds i8, i8* %buf_arg.fca.1.extract, i64 %4 ; [#uses = 1, type = i8*]
  %6 = add nuw nsw i8 %x.0, 48                    ; [#uses = 1]
  store i8 %6, i8* %5, align 1
  %.not = icmp eq i64 %value.1, 0                 ; [#uses = 1]
  br i1 %.not, label %bounds.ok3, label %dowhile

bounds.fail:                                      ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.30, i32 0, i32 0) }, i32 48, i64 %4, i64 %buf_arg.fca.0.extract) #6
  unreachable

bounds.ok3:                                       ; preds = %bounds.ok
  %7 = getelementptr inbounds i8, i8* %buf_arg.fca.1.extract, i64 %4 ; [#uses = 1, type = i8*]
  %8 = sub i64 %buf_arg.fca.0.extract, %4         ; [#uses = 1]
  %9 = insertvalue { i64, i8* } undef, i64 %8, 0  ; [#uses = 1]
  %10 = insertvalue { i64, i8* } %9, i8* %7, 1    ; [#uses = 1]
  ret { i64, i8* } %10
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh(i8* nonnull %.nest_arg, { i64, i8* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %2 = bitcast i8* %1 to i8**                     ; [#uses = 1]
  %.ptr1 = load i8*, i8** %2, align 8             ; [#uses = 1]
  %3 = icmp ugt i8* %r_arg.fca.1.extract, %.ptr1  ; [#uses = 1]
  br i1 %3, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %0
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %4 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 -1 ; [#uses = 1, type = i8*]
  %5 = add i64 %r_arg.fca.0.extract, 1            ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %5, 0  ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %4, 1     ; [#uses = 1]
  ret { i64, i8* } %7

assertFailed:                                     ; preds = %0
  tail call void @_d_assert({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.30, i32 0, i32 0) }, i32 122) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv({ i64, i8* }* dereferenceable(16) %e, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv(%std.stdio.File.LockingTextWriter* nonnull %r, { i64, i8* } %2) #2
  ret void
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, { i64, i8* } %writeme_arg) local_unnamed_addr #0 {
  %writeme_arg.fca.0.extract = extractvalue { i64, i8* } %writeme_arg, 0 ; [#uses = 2]
  %writeme_arg.fca.1.extract = extractvalue { i64, i8* } %writeme_arg, 1 ; [#uses = 1]
  %1 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 1 ; [#uses = 1, type = i32*]
  %2 = load i32, i32* %1, align 4                 ; [#uses = 1]
  %3 = icmp slt i32 %2, 1                         ; [#uses = 1]
  br i1 %3, label %if, label %forcond

if:                                               ; preds = %0
  %4 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %5 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %4, align 8 ; [#uses = 1]
  %6 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %5, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %7 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %6, align 8 ; [#uses = 1]
  %8 = tail call i64 @_D3std5stdio__T13trustedFwriteTaZQsFNbNiNePOS4core4stdcQBx8_IO_FILExAaZm({ i64, i8* } %writeme_arg, %core.stdc.stdio._IO_FILE* %7) #2 ; [#uses = 1]
  %.not = icmp eq i64 %8, %writeme_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not, label %endif2, label %if1

if1:                                              ; preds = %if
  tail call void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } zeroinitializer, i64 3263, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i32 0, i32 0) }) #15
  unreachable

endif2:                                           ; preds = %forcond, %if
  ret void

forcond:                                          ; preds = %0, %forbody
  %__key212.0 = phi i64 [ %11, %forbody ], [ 0, %0 ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %__key212.0, %writeme_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %endif2, label %forbody

forbody:                                          ; preds = %forcond
  %9 = getelementptr inbounds i8, i8* %writeme_arg.fca.1.extract, i64 %__key212.0 ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %10) #0
  %11 = add i64 %__key212.0, 1                    ; [#uses = 1]
  br label %forcond
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5stdio__T13trustedFwriteTaZQsFNbNiNePOS4core4stdcQBx8_IO_FILExAaZm({ i64, i8* } %obj_arg, %core.stdc.stdio._IO_FILE* %f_arg) local_unnamed_addr #0 {
  %obj_arg.fca.0.extract = extractvalue { i64, i8* } %obj_arg, 0 ; [#uses = 1]
  %obj_arg.fca.1.extract = extractvalue { i64, i8* } %obj_arg, 1 ; [#uses = 1]
  %1 = tail call i64 @fwrite(i8* %obj_arg.fca.1.extract, i64 1, i64 %obj_arg.fca.0.extract, %core.stdc.stdio._IO_FILE* %f_arg) #2 ; [#uses = 1]
  ret i64 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std9exception__T7enforceHTCQBcQBb14ErrnoExceptionZ__TQBlTiZQBrFNfiLAxaAyamZi(i64 %line_arg, { i64, i8* } %file_arg, { i8*, { i64, i8* } (i8*)* } %msg_arg, i32 %value_arg) local_unnamed_addr #0 {
  %.not = icmp eq i32 %value_arg, 0               ; [#uses = 1]
  br i1 %.not, label %if, label %endif

if:                                               ; preds = %0
  %msg_arg.fca.1.extract = extractvalue { i8*, { i64, i8* } (i8*)* } %msg_arg, 1 ; [#uses = 1]
  %msg_arg.fca.0.extract = extractvalue { i8*, { i64, i8* } (i8*)* } %msg_arg, 0 ; [#uses = 1]
  %1 = tail call { i64, i8* } %msg_arg.fca.1.extract(i8* nonnull %msg_arg.fca.0.extract) ; [#uses = 1]
  tail call void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } %1, i64 %line_arg, { i64, i8* } %file_arg) #15
  unreachable

endif:                                            ; preds = %0
  ret i32 %value_arg
}

; [#uses = 1]
; Function Attrs: nofree nounwind
declare i64 @fwrite(i8* nocapture, i64, i64, %core.stdc.stdio._IO_FILE* nocapture) local_unnamed_addr #13

; [#uses = 2]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #3 {
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 1]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std9exception14ErrnoException7__ClassZ) #4 ; [#uses = 5]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D3std9exception14ErrnoException6__vtblZ, [10 x i8*]** %vtbl, align 8
  %1 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %1, align 8
  %2 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %3 = bitcast %object.Object* %2 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(64) %3, i8* nonnull align 8 dereferenceable(64) bitcast ({ i64, i8* }* getelementptr inbounds (%std.exception.ErrnoException, %std.exception.ErrnoException* @_D3std9exception14ErrnoException6__initZ, i64 0, i32 2) to i8*), i64 64, i1 false)
  %.not = icmp eq i8* %msg_arg.fca.1.extract, null ; [#uses = 1]
  br i1 %.not, label %condend, label %condtrue

condtrue:                                         ; preds = %0
  %4 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %msg_arg) #2 ; [#uses = 2]
  %.ptr1 = extractvalue { i64, i8* } %4, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %4, 0         ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %condtmp.0.sroa.phi.sroa.speculated = phi i64 [ %.len, %condtrue ], [ 18, %0 ] ; [#uses = 1, type = i64]
  %condtmp.0.sroa.phi7.sroa.speculated = phi i8* [ %.ptr1, %condtrue ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), %0 ] ; [#uses = 1, type = i8*]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.exception.ErrnoException* ; [#uses = 1]
  %.fca.0.insert5 = insertvalue { i64, i8* } undef, i64 %condtmp.0.sroa.phi.sroa.speculated, 0 ; [#uses = 1]
  %.fca.1.insert6 = insertvalue { i64, i8* } %.fca.0.insert5, i8* %condtmp.0.sroa.phi7.sroa.speculated, 1 ; [#uses = 1]
  %5 = tail call %std.exception.ErrnoException* @_D3std9exception14ErrnoException6__ctorMFNfAyaQdmZCQBxQBwQBp(%std.exception.ErrnoException* nonnull returned %.newclass_gc, i64 %line_arg, { i64, i8* } %file_arg, { i64, i8* } %.fca.1.insert6) #2 ; [#uses = 0]
  %6 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %6) #6
  unreachable
}

; [#uses = 1]
declare %std.exception.ErrnoException* @_D3std9exception14ErrnoException6__ctorMFNfAyaQdmZCQBxQBwQBp(%std.exception.ErrnoException* nonnull returned, i64, { i64, i8* }, { i64, i8* }) local_unnamed_addr #2

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File__T5writeTlTaZQlMFNflaZv(%std.stdio.File* nonnull %.this_arg, i8 zeroext %_param_1_arg, i64 %_param_0_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
unrolledstmt:
  %w = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 7, size/byte = 48]
  %__copytmp216 = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 3, size/byte = 48]
  call void @_D3std5stdio4File17lockingTextWriterMFNfZSQBoQBnQBk17LockingTextWriter(%std.stdio.File.LockingTextWriter* noalias nonnull sret align 8 %w, %std.stdio.File* nonnull %.this_arg) #2
  %0 = bitcast %std.stdio.File.LockingTextWriter* %__copytmp216 to i8* ; [#uses = 1]
  %1 = bitcast %std.stdio.File.LockingTextWriter* %w to i8* ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(48) %0, i8* nonnull align 8 dereferenceable(48) %1, i64 48, i1 false)
  invoke void @_D3std5stdio4File17LockingTextWriter14__aggrPostblitMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %__copytmp216) #2
          to label %postinvoke3 unwind label %landingPad2

postinvoke3:                                      ; preds = %unrolledstmt
  invoke void @_D3std4conv__T11toTextRangeTlTSQBd5stdio4File17LockingTextWriterZQBzFNflQBqZv(%std.stdio.File.LockingTextWriter* noalias nocapture nonnull align 8 %__copytmp216, i64 %_param_0_arg) #2
          to label %unrolledstmt1 unwind label %landingPad2

catch.std.utf.UTFException:                       ; preds = %landingPad2
  %2 = call %object.Throwable* @_d_eh_enter_catch(i8* %9) ; [#uses = 1]
  %3 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, i64 0, i32 2 ; [#uses = 1, type = i16*]
  store i16 0, i16* %3, align 4
  invoke void @_d_throw_exception(%object.Throwable* %2) #6
          to label %postinvoke unwind label %landingPad

postinvoke:                                       ; preds = %catch.std.utf.UTFException
  unreachable

unrolledstmt1:                                    ; preds = %postinvoke3
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %w, i8 zeroext %_param_1_arg) #2
          to label %try.success unwind label %landingPad11

catch.std.utf.UTFException7:                      ; preds = %landingPad11
  %4 = call %object.Throwable* @_d_eh_enter_catch(i8* %14) ; [#uses = 1]
  %5 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, i64 0, i32 2 ; [#uses = 1, type = i16*]
  store i16 0, i16* %5, align 4
  invoke void @_d_throw_exception(%object.Throwable* %4) #6
          to label %postinvoke9 unwind label %landingPad

postinvoke9:                                      ; preds = %catch.std.utf.UTFException7
  unreachable

try.success:                                      ; preds = %unrolledstmt1
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #2
  ret void

landingPad:                                       ; preds = %catch.std.utf.UTFException7, %catch.std.utf.UTFException
  %6 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %7 = extractvalue { i8*, i32 } %6, 0            ; [#uses = 1]
  br label %eh.resume

eh.resume:                                        ; preds = %landingPad, %landingPad2, %landingPad11
  %eh.ptr.0.ph = phi i8* [ %14, %landingPad11 ], [ %9, %landingPad2 ], [ %7, %landingPad ] ; [#uses = 1, type = i8*]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #2
  call void @_Unwind_Resume(i8* %eh.ptr.0.ph)
  unreachable

landingPad2:                                      ; preds = %postinvoke3, %unrolledstmt
  %8 = landingpad { i8*, i32 }
          cleanup
          catch %object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ ; [#uses = 2]
  %9 = extractvalue { i8*, i32 } %8, 0            ; [#uses = 2]
  %10 = extractvalue { i8*, i32 } %8, 1           ; [#uses = 1]
  %11 = call i32 @llvm.eh.typeid.for(i8* bitcast (%object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ to i8*)) ; [#uses = 1]
  %12 = icmp eq i32 %10, %11                      ; [#uses = 1]
  br i1 %12, label %catch.std.utf.UTFException, label %eh.resume

landingPad11:                                     ; preds = %unrolledstmt1
  %13 = landingpad { i8*, i32 }
          cleanup
          catch %object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ ; [#uses = 2]
  %14 = extractvalue { i8*, i32 } %13, 0          ; [#uses = 2]
  %15 = extractvalue { i8*, i32 } %13, 1          ; [#uses = 1]
  %16 = call i32 @llvm.eh.typeid.for(i8* bitcast (%object.TypeInfo_Class* @_D3std3utf12UTFException7__ClassZ to i8*)) ; [#uses = 1]
  %17 = icmp eq i32 %15, %16                      ; [#uses = 1]
  br i1 %17, label %catch.std.utf.UTFException7, label %eh.resume
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std4conv__T11toTextRangeTlTSQBd5stdio4File17LockingTextWriterZQBzFNflQBqZv(%std.stdio.File.LockingTextWriter* noalias nocapture align 8 %writer, i64 %value_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %buf5 = alloca [20 x i8], align 1               ; [#uses = 1, size/byte = 20]
  %buf14 = alloca [20 x i8], align 1              ; [#uses = 1, size/byte = 20]
  %1 = icmp slt i64 %value_arg, 0                 ; [#uses = 1]
  br i1 %1, label %if, label %else

if:                                               ; preds = %0
  %buf5.sub = getelementptr inbounds [20 x i8], [20 x i8]* %buf5, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %2 = insertvalue { i64, i8* } { i64 20, i8* undef }, i8* %buf5.sub, 1 ; [#uses = 1]
  %3 = call { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd({ i64, i8* } %2, i64 %value_arg) #0 ; [#uses = 1]
  invoke void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %3, %std.stdio.File.LockingTextWriter* dereferenceable(48) %writer) #0
          to label %try.success unwind label %eh.resume

else:                                             ; preds = %0
  %buf14.sub = getelementptr inbounds [20 x i8], [20 x i8]* %buf14, i64 0, i64 0 ; [#uses = 1, type = i8*]
  %4 = insertvalue { i64, i8* } { i64 20, i8* undef }, i8* %buf14.sub, 1 ; [#uses = 1]
  %5 = call { i64, i8* } @_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd({ i64, i8* } %4, i64 %value_arg) #0 ; [#uses = 1]
  invoke void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %5, %std.stdio.File.LockingTextWriter* dereferenceable(48) %writer) #0
          to label %try.success unwind label %eh.resume

try.success:                                      ; preds = %else, %if
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #2
  ret void

eh.resume:                                        ; preds = %else, %if
  %6 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %7 = extractvalue { i8*, i32 } %6, 0            ; [#uses = 1]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #2
  call void @_Unwind_Resume(i8* %7)
  unreachable
}

; [#uses = 2]
define linkonce_odr hidden void @ldc.register_dso() {
  %1 = alloca { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }, align 8 ; [#uses = 5, size/byte = 32]
  %2 = getelementptr inbounds { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }, { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }* %1, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 1, i64* %2, align 8
  %3 = getelementptr inbounds { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }, { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }* %1, i64 0, i32 1 ; [#uses = 1, type = i8***]
  store i8** @ldc.dso_slot, i8*** %3, align 8
  %4 = getelementptr inbounds { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }, { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }* %1, i64 0, i32 2 ; [#uses = 1, type = %object.ModuleInfo***]
  store %object.ModuleInfo** @__start___minfo, %object.ModuleInfo*** %4, align 8
  %5 = getelementptr inbounds { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }, { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }* %1, i64 0, i32 3 ; [#uses = 1, type = %object.ModuleInfo***]
  store %object.ModuleInfo** @__stop___minfo, %object.ModuleInfo*** %5, align 8
  %6 = bitcast { i64, i8**, %object.ModuleInfo**, %object.ModuleInfo** }* %1 to i8* ; [#uses = 1]
  call void @_d_dso_registry(i8* nonnull %6)
  ret void
}

; [#uses = 1]
; Function Attrs: uwtable
declare void @_d_dso_registry(i8*) local_unnamed_addr #4

; [#uses = 1]
; Function Attrs: nofree nounwind readonly
declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) local_unnamed_addr #14

attributes #0 = { uwtable "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #1 = { uwtable "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16,+cx16" }
attributes #2 = { "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #3 = { noreturn uwtable "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #4 = { uwtable }
attributes #5 = { argmemonly nounwind willreturn }
attributes #6 = { cold noreturn uwtable }
attributes #7 = { argmemonly nounwind willreturn writeonly }
attributes #8 = { noinline uwtable "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #9 = { alwaysinline uwtable "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #10 = { nounwind readnone speculatable willreturn "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #11 = { nounwind uwtable }
attributes #12 = { nounwind readnone }
attributes #13 = { nofree nounwind "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #14 = { nofree nounwind readonly }
attributes #15 = { noreturn "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }
attributes #16 = { noinline "frame-pointer"="none" "target-cpu"="x86-64" "target-features"="+cx16" }

!llvm.ldc.typeinfo._D9Exception7__ClassZ = !{!0}
!llvm.ldc.classinfo._D9Exception7__ClassZ = !{!1}
!llvm.ldc.typeinfo._D12TypeInfo_Axa6__initZ = !{!2}
!llvm.ldc.typeinfo._D12TypeInfo_Aya6__initZ = !{!2}
!llvm.ldc.typeinfo._D11TypeInfo_xm6__initZ = !{!3}
!llvm.ldc.typeinfo._D10TypeInfo_m6__initZ = !{!3}
!llvm.ldc.typeinfo._D14TypeInfo_xAAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D14TypeInfo_AxAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D13TypeInfo_xAya6__initZ = !{!2}
!llvm.ldc.typeinfo._D11TypeInfo_xb6__initZ = !{!5}
!llvm.ldc.typeinfo._D10TypeInfo_b6__initZ = !{!5}
!llvm.ldc.typeinfo._D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ = !{!6}
!llvm.ldc.typeinfo._D13TypeInfo_AAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D3std3utf12UTFException7__ClassZ = !{!7}
!llvm.ldc.classinfo._D3std3utf12UTFException7__ClassZ = !{!8}
!llvm.ldc.typeinfo._D3std4conv21ConvOverflowException7__ClassZ = !{!9}
!llvm.ldc.classinfo._D3std4conv21ConvOverflowException7__ClassZ = !{!10}
!llvm.ldc.typeinfo._D3std4conv13ConvException7__ClassZ = !{!11}
!llvm.ldc.classinfo._D3std4conv13ConvException7__ClassZ = !{!12}
!llvm.ldc.typeinfo._D12TypeInfo_xAa6__initZ = !{!2}
!llvm.ldc.typeinfo._D44TypeInfo_S3std5array__T8AppenderTAyaZQo4Data6__initZ = !{!13}
!llvm.ldc.typeinfo._D11TypeInfo_Aa6__initZ = !{!2}
!llvm.ldc.typeinfo._D6object9Throwable7__ClassZ = !{!14}
!llvm.ldc.classinfo._D6object9Throwable7__ClassZ = !{!15}
!llvm.ldc.typeinfo._D3std9exception14ErrnoException7__ClassZ = !{!16}
!llvm.ldc.classinfo._D3std9exception14ErrnoException7__ClassZ = !{!17}
!llvm.ident = !{!18}

!0 = !{%object.Exception* undef}
!1 = !{%object.Exception undef, i1 false}
!2 = !{{ i64, i8* } undef}
!3 = !{i64 undef}
!4 = !{{ i64, { i64, i8* }* } undef}
!5 = !{i1 undef}
!6 = !{%"std.array.Appender!(string[]).Appender.Data" undef}
!7 = !{%std.utf.UTFException* undef}
!8 = !{%std.utf.UTFException undef, i1 false}
!9 = !{%std.conv.ConvOverflowException* undef}
!10 = !{%std.conv.ConvOverflowException undef, i1 false}
!11 = !{%std.conv.ConvException* undef}
!12 = !{%std.conv.ConvException undef, i1 false}
!13 = !{%"std.array.Appender!string.Appender.Data" undef}
!14 = !{%object.Throwable* undef}
!15 = !{%object.Throwable undef, i1 true}
!16 = !{%std.exception.ErrnoException* undef}
!17 = !{%std.exception.ErrnoException undef, i1 false}
!18 = !{!"ldc version 1.28.0"}
!19 = !{i8 0, i8 2}
!20 = !{i64 0, i64 65}
