import std.stdio;
import std.regex;

void main(){
	auto io = new IO();
	
	auto S = io.line!string()[0];
	
	if ( S.have("N") ^ S.have("S") || S.have("W") ^ S.have("E") ){
		writeln("No");
	}else{
		writeln("Yes");
	}

	return;
}

import std.stdio,std.conv,std.string;
import std.algorithm,std.array,std.math;

class IO
{
	T[] line( T = size_t , string token = " " )( size_t m = 1 ){
		T[] arr = [];
		foreach( i ; 0..m ){
			arr ~= this.read!T();
		}
		return arr;
	}
	T[][] rect( T = size_t , string token = " " )( size_t m = 1 ){
		T[][] arr = new T[][](m);
		foreach( i ; 0..m ){
			arr[i] = this.read!T(token);
		}
		return arr;
	}
	private T[] read( T = size_t )( string token = " " ){
		T[] arr;
		foreach( elm ; readln().chomp().split(token) ){
			arr ~= elm.to!T();
		}
		return arr;
	}
}

// T -> T[]
pure T[] step( T = size_t )( in T begin , in T end , in T step = 1 ){
	T[] ret;
	for( T i = begin ; i < end ; i += step ){
		ret ~= i;
	}
	return ret;
}
unittest{
	assert( step(0,10,2) == [0,2,4,6,8] );
}

// T[] -> T[]
pure T[] fill( T )( T[] args , in T filling ){
	foreach( ref arg ; args ){
		arg = filling;
	}
	return args;
}
T[] map( T )( T[] args , T function(T) f ){
	foreach( ref arg ; args ){
		arg = f(arg);
	}
	return args;
}
unittest{
	assert( [true,false,true,false].fill(true) == [true,true,true,true] );
	assert( [1,-2,3,-4].map!int(x=>x*2) == [2,-4,6,-8] );
}
// T[] -> number
pure T sum( T )( in T[] args ){
	T ret = 0;
	foreach( i ; 0..args.length ){
		ret += args[i];
	}
	return ret;
}
pure T ave(T)( in T[] args ){
	return args.sum()/args.length;
}
pure real multi( in real[] args ){
	real ret = 1.0;
	foreach( i ; 0..args.length ){
		ret *= args[i];
	}
	return ret;
}

// T[] -> bool
pure bool any( T )( in T[] args , in T target ){
	foreach( arg ; args ){
		if( arg == target ){return true;}
	}
	return false;
}
pure bool all( T )( in T[] args , in T cond ){
	foreach( arg ; args ){
		if( arg != cond ){return false;}
	}
	return true;
}
pure bool have( T )( in T[] args , in T[] target ... ){
	bool[] found = new bool[](target.length);
	foreach( arg ; args ){
		foreach( i,t ; target ){
			if( arg == t ){
				found[i] = true;
			}
		}
	}
	foreach( f ; found ){
		if( f == false ){return false;}
	}
	return true;
}


unittest{
	assert( [1,2,3,4,5].sum() == 15 );
	assert( [1,2,3,4,5].ave() == 3 );
	assert( cmp( [0.3,0.3].multi() , 0.09 ) , "multi() test failed" );
	assert( cmp( [0.3,0.3,0.3].multi() , 0.027 ) , "multi() test failed" );
	
	assert( [1,1,1].all(1) == true );
	assert( [1,1,2].all(1) == false );
	assert( [1,1,2].any(2) == true );
	assert( [1,1,2].any(3) == false );
	
	assert( [1,2,3,4,5].have([1,3,5]) == true );
	assert( [1,2,3,4,5].have([1,3,5,7]) == false );
}

; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/D/Source_14758/source.d'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/D/Source_14758/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 opaque
%3 = type opaque
%4 = type opaque
%5 = type opaque
%6 = type opaque
%7 = type { i32, i32, i64, [7 x %object.ModuleInfo*], i64, [1 x %object.TypeInfo_Class*], [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* }
%source.IO = type { [5 x i8*]*, i8* }
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%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 }>
%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result" = type { { i64, i8* }, { i64, i8* }, i64 }
%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.exception.ErrnoException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, i32 }>
%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 }>
%object.ModuleInfo = type { i32, i32 }
%std.stdio.File.LockingTextWriter = type { %std.stdio.File, i32, i16, [4 x i8], [6 x i8], i64 }
%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.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] }
%core.memory.BlkInfo_ = type { i8*, i64, i32, [4 x i8] }
%core.memory.GC.Stats = type { i64, i64, i64 }
%"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S" = type { { i64, i8* } }
%nest.decodeImpl = type { i8*, i64 }

@_D6source2IO7__ClassZ = global %object.TypeInfo_Class { [20 x i8*]* @_D14TypeInfo_Class6__vtblZ, i8* null, { i64, i8* } { i64 16, i8* bitcast (%source.IO* @_D6source2IO6__initZ to i8*) }, { i64, i8* } { i64 9, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0) }, { i64, i8** } { i64 5, i8** getelementptr inbounds ([5 x i8*], [5 x i8*]* @_D6source2IO6__vtblZ, i32 0, i32 0) }, { i64, %object.Interface* } zeroinitializer, %object.TypeInfo_Class* @_D6Object7__ClassZ, i8* null, void (%object.Object*)* null, i32 54, [4 x i8] zeroinitializer, i8* null, { i64, %object.OffsetTypeInfo* } zeroinitializer, void (%object.Object*)* null, i8* null } ; [#uses = 3]
@_D6source2IO6__vtblZ = constant [5 x i8*] [i8* bitcast (%object.TypeInfo_Class* @_D6source2IO7__ClassZ to i8*), i8* bitcast ({ i64, i8* } (%object.Object*)* @_D6object6Object8toStringMFZAya to i8*), i8* bitcast (i64 (%object.Object*)* @_D6object6Object6toHashMFNbNeZm to i8*), i8* bitcast (i32 (%object.Object*, %object.Object*)* @_D6object6Object5opCmpMFCQqZi to i8*), i8* bitcast (i1 (%object.Object*, %object.Object*)* @_D6object6Object8opEqualsMFCQtZb to i8*)] ; [#uses = 3]
@.str = private unnamed_addr constant [62 x i8] c"/data/TheStack_IR/OJ_Samples/Collated/D/Source_14758/source.d\00" ; [#uses = 1]
@.str.5 = private unnamed_addr constant [3 x i8] c"No\00" ; [#uses = 1]
@.str.6 = private unnamed_addr constant [4 x i8] c"Yes\00" ; [#uses = 1]
@_D6source2IO6__initZ = constant %source.IO { [5 x i8*]* @_D6source2IO6__vtblZ, i8* null }, align 8 ; [#uses = 1]
@_D14TypeInfo_Class6__vtblZ = external constant [20 x i8*] ; [#uses = 1]
@.str.7 = private unnamed_addr constant [10 x i8] c"source.IO\00" ; [#uses = 1]
@_D6Object7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@.str.8 = private unnamed_addr constant [2 x i8] c" \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]
@_D14TypeInfo_Array6__vtblZ = external constant [19 x i8*] ; [#uses = 2]
@_D12TypeInfo_Aya6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.9 = private unnamed_addr constant [39 x i8] c"Attempt to read from an unopened file.\00" ; [#uses = 1]
@.str.10 = 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.11 = private unnamed_addr constant [19 x i8] c"Enforcement failed\00" ; [#uses = 1]
@_D12TypeInfo_Axa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.13 = private unnamed_addr constant [28 x i8] c"The input must not be empty\00" ; [#uses = 1]
@.str.14 = private unnamed_addr constant [66 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/algorithm/iteration.d\00" ; [#uses = 1]
@.str.15 = private unnamed_addr constant [52 x i8] c"Attempting to fetch the front of an empty splitter.\00" ; [#uses = 1]
@.str.16 = private unnamed_addr constant [42 x i8] c"Attempting to popFront an empty splitter.\00" ; [#uses = 1]
@_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result6__initZ = weak_odr local_unnamed_addr constant %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result" { { i64, i8* } zeroinitializer, { i64, i8* } zeroinitializer, i64 -1 }, align 8 ; [#uses = 0]
@_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 = 5]
@_D14TypeInfo_Const6__vtblZ = external constant [19 x i8*] ; [#uses = 4]
@_D11TypeInfo_xm6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_m6__initZ } ; [#uses = 3]
@_D10TypeInfo_m6__initZ = external global %object.TypeInfo ; [#uses = 1]
@.str.17 = private unnamed_addr constant [66 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/algorithm/searching.d\00" ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i40i10ZQyyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 40, i64 10], align 8 ; [#uses = 0]
@_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]
@_D11TypeInfo_xb6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_b6__initZ } ; [#uses = 2]
@_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.18, 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 = 1]
@.str.18 = 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.19 = private unnamed_addr constant [58 x i8] c"the reallocation would exceed the available pointer range\00" ; [#uses = 1]
@.str.20 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/array.d\00" ; [#uses = 1]
@.str.21 = private unnamed_addr constant [54 x i8] c"Attempting to shrink Appender with newlength > length\00" ; [#uses = 1]
@.str.22 = private unnamed_addr constant [60 x i8] c"Attempting to shrink empty Appender with non-zero newlength\00" ; [#uses = 1]
@.str.23 = private unnamed_addr constant [9 x i8] c"string[]\00" ; [#uses = 1]
@.str.24 = 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]
@_D6object__T10RTInfoImplVAmA2i16i2ZQxyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 16, i64 2], align 8 ; [#uses = 0]
@_D6object__T10RTInfoImplVAmA2i8i1ZQwyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 8, i64 1], align 8 ; [#uses = 0]
@_D11TypeInfo_Ab6__initZ = external global %object.TypeInfo_Array ; [#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]
@.str.25 = private unnamed_addr constant [50 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/utf.d\00" ; [#uses = 1]
@.str.26 = private unnamed_addr constant [23 x i8] c"Invalid UTF-8 sequence\00" ; [#uses = 1]
@.str.27 = private unnamed_addr constant [45 x i8] c"Attempted to decode past the end of a string\00" ; [#uses = 1]
@_D3std3utf12UTFException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 5]
@_D3std3utf12UTFException6__vtblZ = external constant [11 x i8*] ; [#uses = 5]
@_D3std3utf12UTFException6__initZ = external local_unnamed_addr constant %std.utf.UTFException, align 8 ; [#uses = 1]
@.str.28 = private unnamed_addr constant [41 x i8] c"Encoding an invalid code point in UTF-32\00" ; [#uses = 1]
@_D3std4conv12__ModuleInfoZ = external global %0  ; [#uses = 1]
@_D3std5array12__ModuleInfoZ = external global %1 ; [#uses = 1]
@_D3std9exception12__ModuleInfoZ = external global %2 ; [#uses = 1]
@_D3std3uni12__ModuleInfoZ = external global %3   ; [#uses = 1]
@_D4core6memory12__ModuleInfoZ = external global %4 ; [#uses = 1]
@_D3std6format4spec12__ModuleInfoZ = external global %5 ; [#uses = 1]
@_D3std6traits12__ModuleInfoZ = external global %6 ; [#uses = 1]
@_D6source12__ModuleInfoZ = global %7 { i32 -2147480576, i32 0, i64 7, [7 x %object.ModuleInfo*] [%object.ModuleInfo* bitcast (%0* @_D3std4conv12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%1* @_D3std5array12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%2* @_D3std9exception12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%3* @_D3std3uni12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%4* @_D4core6memory12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%5* @_D3std6format4spec12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%6* @_D3std6traits12__ModuleInfoZ to %object.ModuleInfo*)], i64 1, [1 x %object.TypeInfo_Class*] [%object.TypeInfo_Class* @_D6source2IO7__ClassZ], [7 x i8] c"source\00" } ; [#uses = 1]
@_D6source11__moduleRefZ = linkonce_odr hidden global %object.ModuleInfo* bitcast (%7* @_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 i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #0 {
forbody.i:
  %.nongc_mem90 = alloca i8, align 1              ; [#uses = 4, size/byte = 1]
  store i8 0, i8* %.nongc_mem90, align 1
  %.nongc_mem89 = alloca i8, align 1              ; [#uses = 4, size/byte = 1]
  store i8 0, i8* %.nongc_mem89, align 1
  %.nongc_mem88 = alloca i8, align 1              ; [#uses = 4, size/byte = 1]
  store i8 0, i8* %.nongc_mem88, align 1
  %.nongc_mem = alloca i8, align 1                ; [#uses = 4, size/byte = 1]
  store i8 0, i8* %.nongc_mem, align 1
  %arr.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 2, size/byte = 16]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D6source2IO7__ClassZ) #1 ; [#uses = 3]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %source.IO* ; [#uses = 1]
  %vtbl = getelementptr %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 0 ; [#uses = 1, type = [5 x i8*]**]
  store [5 x i8*]* @_D6source2IO6__vtblZ, [5 x i8*]** %vtbl, align 8
  %0 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %0, align 8
  %1 = bitcast { i64, { i64, i8* }* }* %arr.i to i8* ; [#uses = 3]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %1)
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %1, i8 0, i64 16, i1 false)
  %2 = bitcast { i64, { i64, i8* }* }* %arr.i to { i64, i8* }* ; [#uses = 1]
  %3 = call { i64, { i64, i8* }* } @_D6source2IO__T4readTAyaZQkMFQiZAQm(%source.IO* nonnull %.newclass_gc, { i64, i8* } { i64 1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i32 0, i32 0) }) #4 ; [#uses = 2]
  %4 = extractvalue { i64, { i64, i8* }* } %3, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } undef, i64 %4, 0  ; [#uses = 1]
  %6 = extractvalue { i64, { i64, i8* }* } %3, 1  ; [#uses = 1]
  %7 = bitcast { i64, i8* }* %6 to i8*            ; [#uses = 1]
  %8 = insertvalue { i64, i8* } %5, i8* %7, 1     ; [#uses = 1]
  %.appendedArray.i = call { i64, i8* } @_d_arrayappendT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), { i64, i8* }* nonnull dereferenceable(16) %2, { i64, i8* } %8) #1 ; [#uses = 2]
  %.len.i = extractvalue { i64, i8* } %.appendedArray.i, 0 ; [#uses = 1]
  %.ptr.i = extractvalue { i64, i8* } %.appendedArray.i, 1 ; [#uses = 2]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %1)
  %bounds.cmp.not = icmp eq i64 %.len.i, 0        ; [#uses = 1]
  br i1 %bounds.cmp.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody.i
  %9 = getelementptr inbounds i8, i8* %.ptr.i, i64 8 ; [#uses = 1, type = i8*]
  %10 = bitcast i8* %9 to i8**                    ; [#uses = 1]
  %.ptr1 = load i8*, i8** %10, align 8            ; [#uses = 20]
  %11 = bitcast i8* %.ptr.i to i64*               ; [#uses = 1]
  %.len2 = load i64, i64* %11, align 8            ; [#uses = 13]
  %.not.i = icmp eq i64 %.len2, 0                 ; [#uses = 4]
  br i1 %.not.i, label %forcond17.preheader.i, label %forbody.us.i.preheader

forbody.us.i.preheader:                           ; preds = %bounds.ok
  %.nongc_mem.promoted = load i8, i8* %.nongc_mem, align 1 ; [#uses = 2]
  %12 = add i64 %.len2, -1                        ; [#uses = 1]
  %xtraiter115 = and i64 %.len2, 3                ; [#uses = 2]
  %13 = icmp ult i64 %12, 3                       ; [#uses = 1]
  br i1 %13, label %forcond17.preheader.i.loopexit.unr-lcssa, label %forbody.us.i.preheader.new

forbody.us.i.preheader.new:                       ; preds = %forbody.us.i.preheader
  %unroll_iter120 = and i64 %.len2, -4            ; [#uses = 1]
  br label %forbody.us.i

forbody.us.i:                                     ; preds = %forbody.us.i, %forbody.us.i.preheader.new
  %14 = phi i8 [ %.nongc_mem.promoted, %forbody.us.i.preheader.new ], [ %spec.select.3, %forbody.us.i ] ; [#uses = 1, type = i8]
  %__key243.040.us.i = phi i64 [ 0, %forbody.us.i.preheader.new ], [ %33, %forbody.us.i ] ; [#uses = 5, type = i64]
  %niter121 = phi i64 [ %unroll_iter120, %forbody.us.i.preheader.new ], [ %niter121.nsub.3, %forbody.us.i ] ; [#uses = 1, type = i64]
  %15 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %17 = icmp eq i8 %16, 78                        ; [#uses = 1]
  %18 = or i64 %__key243.040.us.i, 1              ; [#uses = 1]
  %19 = getelementptr inbounds i8, i8* %.ptr1, i64 %18 ; [#uses = 1, type = i8*]
  %20 = load i8, i8* %19, align 1                 ; [#uses = 1]
  %21 = icmp eq i8 %20, 78                        ; [#uses = 1]
  %22 = or i1 %21, %17                            ; [#uses = 1]
  %23 = or i64 %__key243.040.us.i, 2              ; [#uses = 1]
  %24 = getelementptr inbounds i8, i8* %.ptr1, i64 %23 ; [#uses = 1, type = i8*]
  %25 = load i8, i8* %24, align 1                 ; [#uses = 1]
  %26 = icmp eq i8 %25, 78                        ; [#uses = 1]
  %27 = or i1 %26, %22                            ; [#uses = 1]
  %28 = or i64 %__key243.040.us.i, 3              ; [#uses = 1]
  %29 = getelementptr inbounds i8, i8* %.ptr1, i64 %28 ; [#uses = 1, type = i8*]
  %30 = load i8, i8* %29, align 1                 ; [#uses = 1]
  %31 = icmp eq i8 %30, 78                        ; [#uses = 1]
  %32 = or i1 %31, %27                            ; [#uses = 1]
  %spec.select.3 = select i1 %32, i8 1, i8 %14    ; [#uses = 3]
  %33 = add nuw i64 %__key243.040.us.i, 4         ; [#uses = 2]
  %niter121.nsub.3 = add i64 %niter121, -4        ; [#uses = 2]
  %niter121.ncmp.3 = icmp eq i64 %niter121.nsub.3, 0 ; [#uses = 1]
  br i1 %niter121.ncmp.3, label %forcond17.preheader.i.loopexit.unr-lcssa, label %forbody.us.i

forcond17.preheader.i.loopexit.unr-lcssa:         ; preds = %forbody.us.i, %forbody.us.i.preheader
  %spec.select.lcssa.ph = phi i8 [ undef, %forbody.us.i.preheader ], [ %spec.select.3, %forbody.us.i ] ; [#uses = 1, type = i8]
  %.unr117 = phi i8 [ %.nongc_mem.promoted, %forbody.us.i.preheader ], [ %spec.select.3, %forbody.us.i ] ; [#uses = 1, type = i8]
  %__key243.040.us.i.unr = phi i64 [ 0, %forbody.us.i.preheader ], [ %33, %forbody.us.i ] ; [#uses = 1, type = i64]
  %lcmp.mod118.not = icmp eq i64 %xtraiter115, 0  ; [#uses = 1]
  br i1 %lcmp.mod118.not, label %forcond17.preheader.i.loopexit, label %forbody.us.i.epil

forbody.us.i.epil:                                ; preds = %forcond17.preheader.i.loopexit.unr-lcssa, %forbody.us.i.epil
  %34 = phi i8 [ %spec.select.epil, %forbody.us.i.epil ], [ %.unr117, %forcond17.preheader.i.loopexit.unr-lcssa ] ; [#uses = 1, type = i8]
  %__key243.040.us.i.epil = phi i64 [ %38, %forbody.us.i.epil ], [ %__key243.040.us.i.unr, %forcond17.preheader.i.loopexit.unr-lcssa ] ; [#uses = 2, type = i64]
  %epil.iter116 = phi i64 [ %epil.iter116.sub, %forbody.us.i.epil ], [ %xtraiter115, %forcond17.preheader.i.loopexit.unr-lcssa ] ; [#uses = 1, type = i64]
  %35 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i.epil ; [#uses = 1, type = i8*]
  %36 = load i8, i8* %35, align 1                 ; [#uses = 1]
  %37 = icmp eq i8 %36, 78                        ; [#uses = 1]
  %spec.select.epil = select i1 %37, i8 1, i8 %34 ; [#uses = 2]
  %38 = add nuw i64 %__key243.040.us.i.epil, 1    ; [#uses = 1]
  %epil.iter116.sub = add i64 %epil.iter116, -1   ; [#uses = 2]
  %epil.iter116.cmp.not = icmp eq i64 %epil.iter116.sub, 0 ; [#uses = 1]
  br i1 %epil.iter116.cmp.not, label %forcond17.preheader.i.loopexit, label %forbody.us.i.epil, !llvm.loop !16

forcond17.preheader.i.loopexit:                   ; preds = %forbody.us.i.epil, %forcond17.preheader.i.loopexit.unr-lcssa
  %spec.select.lcssa = phi i8 [ %spec.select.lcssa.ph, %forcond17.preheader.i.loopexit.unr-lcssa ], [ %spec.select.epil, %forbody.us.i.epil ] ; [#uses = 1, type = i8]
  store i8 %spec.select.lcssa, i8* %.nongc_mem, align 1
  br label %forcond17.preheader.i

forcond17.preheader.i:                            ; preds = %forcond17.preheader.i.loopexit, %bounds.ok
  %39 = load i8, i8* %.nongc_mem, align 1, !range !18 ; [#uses = 1]
  %.not = icmp eq i8 %39, 0                       ; [#uses = 2]
  br i1 %.not.i, label %forcond17.preheader.i40, label %forbody.us.i32.preheader

forbody.us.i32.preheader:                         ; preds = %forcond17.preheader.i
  %.nongc_mem88.promoted = load i8, i8* %.nongc_mem88, align 1 ; [#uses = 2]
  %40 = add i64 %.len2, -1                        ; [#uses = 1]
  %xtraiter108 = and i64 %.len2, 3                ; [#uses = 2]
  %41 = icmp ult i64 %40, 3                       ; [#uses = 1]
  br i1 %41, label %forcond17.preheader.i40.loopexit.unr-lcssa, label %forbody.us.i32.preheader.new

forbody.us.i32.preheader.new:                     ; preds = %forbody.us.i32.preheader
  %unroll_iter113 = and i64 %.len2, -4            ; [#uses = 1]
  br label %forbody.us.i32

forbody.us.i32:                                   ; preds = %forbody.us.i32, %forbody.us.i32.preheader.new
  %42 = phi i8 [ %.nongc_mem88.promoted, %forbody.us.i32.preheader.new ], [ %spec.select95.3, %forbody.us.i32 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i31 = phi i64 [ 0, %forbody.us.i32.preheader.new ], [ %61, %forbody.us.i32 ] ; [#uses = 5, type = i64]
  %niter114 = phi i64 [ %unroll_iter113, %forbody.us.i32.preheader.new ], [ %niter114.nsub.3, %forbody.us.i32 ] ; [#uses = 1, type = i64]
  %43 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i31 ; [#uses = 1, type = i8*]
  %44 = load i8, i8* %43, align 1                 ; [#uses = 1]
  %45 = icmp eq i8 %44, 83                        ; [#uses = 1]
  %46 = or i64 %__key243.040.us.i31, 1            ; [#uses = 1]
  %47 = getelementptr inbounds i8, i8* %.ptr1, i64 %46 ; [#uses = 1, type = i8*]
  %48 = load i8, i8* %47, align 1                 ; [#uses = 1]
  %49 = icmp eq i8 %48, 83                        ; [#uses = 1]
  %50 = or i1 %49, %45                            ; [#uses = 1]
  %51 = or i64 %__key243.040.us.i31, 2            ; [#uses = 1]
  %52 = getelementptr inbounds i8, i8* %.ptr1, i64 %51 ; [#uses = 1, type = i8*]
  %53 = load i8, i8* %52, align 1                 ; [#uses = 1]
  %54 = icmp eq i8 %53, 83                        ; [#uses = 1]
  %55 = or i1 %54, %50                            ; [#uses = 1]
  %56 = or i64 %__key243.040.us.i31, 3            ; [#uses = 1]
  %57 = getelementptr inbounds i8, i8* %.ptr1, i64 %56 ; [#uses = 1, type = i8*]
  %58 = load i8, i8* %57, align 1                 ; [#uses = 1]
  %59 = icmp eq i8 %58, 83                        ; [#uses = 1]
  %60 = or i1 %59, %55                            ; [#uses = 1]
  %spec.select95.3 = select i1 %60, i8 1, i8 %42  ; [#uses = 3]
  %61 = add nuw i64 %__key243.040.us.i31, 4       ; [#uses = 2]
  %niter114.nsub.3 = add i64 %niter114, -4        ; [#uses = 2]
  %niter114.ncmp.3 = icmp eq i64 %niter114.nsub.3, 0 ; [#uses = 1]
  br i1 %niter114.ncmp.3, label %forcond17.preheader.i40.loopexit.unr-lcssa, label %forbody.us.i32

forcond17.preheader.i40.loopexit.unr-lcssa:       ; preds = %forbody.us.i32, %forbody.us.i32.preheader
  %spec.select95.lcssa.ph = phi i8 [ undef, %forbody.us.i32.preheader ], [ %spec.select95.3, %forbody.us.i32 ] ; [#uses = 1, type = i8]
  %.unr110 = phi i8 [ %.nongc_mem88.promoted, %forbody.us.i32.preheader ], [ %spec.select95.3, %forbody.us.i32 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i31.unr = phi i64 [ 0, %forbody.us.i32.preheader ], [ %61, %forbody.us.i32 ] ; [#uses = 1, type = i64]
  %lcmp.mod111.not = icmp eq i64 %xtraiter108, 0  ; [#uses = 1]
  br i1 %lcmp.mod111.not, label %forcond17.preheader.i40.loopexit, label %forbody.us.i32.epil

forbody.us.i32.epil:                              ; preds = %forcond17.preheader.i40.loopexit.unr-lcssa, %forbody.us.i32.epil
  %62 = phi i8 [ %spec.select95.epil, %forbody.us.i32.epil ], [ %.unr110, %forcond17.preheader.i40.loopexit.unr-lcssa ] ; [#uses = 1, type = i8]
  %__key243.040.us.i31.epil = phi i64 [ %66, %forbody.us.i32.epil ], [ %__key243.040.us.i31.unr, %forcond17.preheader.i40.loopexit.unr-lcssa ] ; [#uses = 2, type = i64]
  %epil.iter109 = phi i64 [ %epil.iter109.sub, %forbody.us.i32.epil ], [ %xtraiter108, %forcond17.preheader.i40.loopexit.unr-lcssa ] ; [#uses = 1, type = i64]
  %63 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i31.epil ; [#uses = 1, type = i8*]
  %64 = load i8, i8* %63, align 1                 ; [#uses = 1]
  %65 = icmp eq i8 %64, 83                        ; [#uses = 1]
  %spec.select95.epil = select i1 %65, i8 1, i8 %62 ; [#uses = 2]
  %66 = add nuw i64 %__key243.040.us.i31.epil, 1  ; [#uses = 1]
  %epil.iter109.sub = add i64 %epil.iter109, -1   ; [#uses = 2]
  %epil.iter109.cmp.not = icmp eq i64 %epil.iter109.sub, 0 ; [#uses = 1]
  br i1 %epil.iter109.cmp.not, label %forcond17.preheader.i40.loopexit, label %forbody.us.i32.epil, !llvm.loop !19

forcond17.preheader.i40.loopexit:                 ; preds = %forbody.us.i32.epil, %forcond17.preheader.i40.loopexit.unr-lcssa
  %spec.select95.lcssa = phi i8 [ %spec.select95.lcssa.ph, %forcond17.preheader.i40.loopexit.unr-lcssa ], [ %spec.select95.epil, %forbody.us.i32.epil ] ; [#uses = 1, type = i8]
  store i8 %spec.select95.lcssa, i8* %.nongc_mem88, align 1
  br label %forcond17.preheader.i40

forcond17.preheader.i40:                          ; preds = %forcond17.preheader.i40.loopexit, %forcond17.preheader.i
  %67 = load i8, i8* %.nongc_mem88, align 1, !range !18 ; [#uses = 1]
  %68 = icmp eq i8 %67, 0                         ; [#uses = 1]
  br i1 %68, label %forbody18.i44._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit46_crit_edge, label %forcond17.i42

forcond17.i42:                                    ; preds = %forcond17.preheader.i40
  br i1 %.not, label %endif, label %oror

forbody18.i44._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit46_crit_edge: ; preds = %forcond17.preheader.i40
  br i1 %.not, label %oror, label %endif

oror:                                             ; preds = %forcond17.i42, %forbody18.i44._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit46_crit_edge
  br i1 %.not.i, label %forcond17.preheader.i60, label %forbody.us.i52.preheader

forbody.us.i52.preheader:                         ; preds = %oror
  %.nongc_mem89.promoted = load i8, i8* %.nongc_mem89, align 1 ; [#uses = 2]
  %69 = add i64 %.len2, -1                        ; [#uses = 1]
  %xtraiter101 = and i64 %.len2, 3                ; [#uses = 2]
  %70 = icmp ult i64 %69, 3                       ; [#uses = 1]
  br i1 %70, label %forcond17.preheader.i60.loopexit.unr-lcssa, label %forbody.us.i52.preheader.new

forbody.us.i52.preheader.new:                     ; preds = %forbody.us.i52.preheader
  %unroll_iter106 = and i64 %.len2, -4            ; [#uses = 1]
  br label %forbody.us.i52

forbody.us.i52:                                   ; preds = %forbody.us.i52, %forbody.us.i52.preheader.new
  %71 = phi i8 [ %.nongc_mem89.promoted, %forbody.us.i52.preheader.new ], [ %spec.select96.3, %forbody.us.i52 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i51 = phi i64 [ 0, %forbody.us.i52.preheader.new ], [ %90, %forbody.us.i52 ] ; [#uses = 5, type = i64]
  %niter107 = phi i64 [ %unroll_iter106, %forbody.us.i52.preheader.new ], [ %niter107.nsub.3, %forbody.us.i52 ] ; [#uses = 1, type = i64]
  %72 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i51 ; [#uses = 1, type = i8*]
  %73 = load i8, i8* %72, align 1                 ; [#uses = 1]
  %74 = icmp eq i8 %73, 87                        ; [#uses = 1]
  %75 = or i64 %__key243.040.us.i51, 1            ; [#uses = 1]
  %76 = getelementptr inbounds i8, i8* %.ptr1, i64 %75 ; [#uses = 1, type = i8*]
  %77 = load i8, i8* %76, align 1                 ; [#uses = 1]
  %78 = icmp eq i8 %77, 87                        ; [#uses = 1]
  %79 = or i1 %78, %74                            ; [#uses = 1]
  %80 = or i64 %__key243.040.us.i51, 2            ; [#uses = 1]
  %81 = getelementptr inbounds i8, i8* %.ptr1, i64 %80 ; [#uses = 1, type = i8*]
  %82 = load i8, i8* %81, align 1                 ; [#uses = 1]
  %83 = icmp eq i8 %82, 87                        ; [#uses = 1]
  %84 = or i1 %83, %79                            ; [#uses = 1]
  %85 = or i64 %__key243.040.us.i51, 3            ; [#uses = 1]
  %86 = getelementptr inbounds i8, i8* %.ptr1, i64 %85 ; [#uses = 1, type = i8*]
  %87 = load i8, i8* %86, align 1                 ; [#uses = 1]
  %88 = icmp eq i8 %87, 87                        ; [#uses = 1]
  %89 = or i1 %88, %84                            ; [#uses = 1]
  %spec.select96.3 = select i1 %89, i8 1, i8 %71  ; [#uses = 3]
  %90 = add nuw i64 %__key243.040.us.i51, 4       ; [#uses = 2]
  %niter107.nsub.3 = add i64 %niter107, -4        ; [#uses = 2]
  %niter107.ncmp.3 = icmp eq i64 %niter107.nsub.3, 0 ; [#uses = 1]
  br i1 %niter107.ncmp.3, label %forcond17.preheader.i60.loopexit.unr-lcssa, label %forbody.us.i52

forcond17.preheader.i60.loopexit.unr-lcssa:       ; preds = %forbody.us.i52, %forbody.us.i52.preheader
  %spec.select96.lcssa.ph = phi i8 [ undef, %forbody.us.i52.preheader ], [ %spec.select96.3, %forbody.us.i52 ] ; [#uses = 1, type = i8]
  %.unr103 = phi i8 [ %.nongc_mem89.promoted, %forbody.us.i52.preheader ], [ %spec.select96.3, %forbody.us.i52 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i51.unr = phi i64 [ 0, %forbody.us.i52.preheader ], [ %90, %forbody.us.i52 ] ; [#uses = 1, type = i64]
  %lcmp.mod104.not = icmp eq i64 %xtraiter101, 0  ; [#uses = 1]
  br i1 %lcmp.mod104.not, label %forcond17.preheader.i60.loopexit, label %forbody.us.i52.epil

forbody.us.i52.epil:                              ; preds = %forcond17.preheader.i60.loopexit.unr-lcssa, %forbody.us.i52.epil
  %91 = phi i8 [ %spec.select96.epil, %forbody.us.i52.epil ], [ %.unr103, %forcond17.preheader.i60.loopexit.unr-lcssa ] ; [#uses = 1, type = i8]
  %__key243.040.us.i51.epil = phi i64 [ %95, %forbody.us.i52.epil ], [ %__key243.040.us.i51.unr, %forcond17.preheader.i60.loopexit.unr-lcssa ] ; [#uses = 2, type = i64]
  %epil.iter102 = phi i64 [ %epil.iter102.sub, %forbody.us.i52.epil ], [ %xtraiter101, %forcond17.preheader.i60.loopexit.unr-lcssa ] ; [#uses = 1, type = i64]
  %92 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i51.epil ; [#uses = 1, type = i8*]
  %93 = load i8, i8* %92, align 1                 ; [#uses = 1]
  %94 = icmp eq i8 %93, 87                        ; [#uses = 1]
  %spec.select96.epil = select i1 %94, i8 1, i8 %91 ; [#uses = 2]
  %95 = add nuw i64 %__key243.040.us.i51.epil, 1  ; [#uses = 1]
  %epil.iter102.sub = add i64 %epil.iter102, -1   ; [#uses = 2]
  %epil.iter102.cmp.not = icmp eq i64 %epil.iter102.sub, 0 ; [#uses = 1]
  br i1 %epil.iter102.cmp.not, label %forcond17.preheader.i60.loopexit, label %forbody.us.i52.epil, !llvm.loop !20

forcond17.preheader.i60.loopexit:                 ; preds = %forbody.us.i52.epil, %forcond17.preheader.i60.loopexit.unr-lcssa
  %spec.select96.lcssa = phi i8 [ %spec.select96.lcssa.ph, %forcond17.preheader.i60.loopexit.unr-lcssa ], [ %spec.select96.epil, %forbody.us.i52.epil ] ; [#uses = 1, type = i8]
  store i8 %spec.select96.lcssa, i8* %.nongc_mem89, align 1
  br label %forcond17.preheader.i60

forcond17.preheader.i60:                          ; preds = %forcond17.preheader.i60.loopexit, %oror
  %96 = load i8, i8* %.nongc_mem89, align 1, !range !18 ; [#uses = 1]
  %.not99 = icmp eq i8 %96, 0                     ; [#uses = 2]
  br i1 %.not.i, label %forcond17.preheader.i80, label %forbody.us.i72.preheader

forbody.us.i72.preheader:                         ; preds = %forcond17.preheader.i60
  %.nongc_mem90.promoted = load i8, i8* %.nongc_mem90, align 1 ; [#uses = 2]
  %97 = add i64 %.len2, -1                        ; [#uses = 1]
  %xtraiter = and i64 %.len2, 3                   ; [#uses = 2]
  %98 = icmp ult i64 %97, 3                       ; [#uses = 1]
  br i1 %98, label %forcond17.preheader.i80.loopexit.unr-lcssa, label %forbody.us.i72.preheader.new

forbody.us.i72.preheader.new:                     ; preds = %forbody.us.i72.preheader
  %unroll_iter = and i64 %.len2, -4               ; [#uses = 1]
  br label %forbody.us.i72

forbody.us.i72:                                   ; preds = %forbody.us.i72, %forbody.us.i72.preheader.new
  %99 = phi i8 [ %.nongc_mem90.promoted, %forbody.us.i72.preheader.new ], [ %spec.select98.3, %forbody.us.i72 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i71 = phi i64 [ 0, %forbody.us.i72.preheader.new ], [ %118, %forbody.us.i72 ] ; [#uses = 5, type = i64]
  %niter = phi i64 [ %unroll_iter, %forbody.us.i72.preheader.new ], [ %niter.nsub.3, %forbody.us.i72 ] ; [#uses = 1, type = i64]
  %100 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i71 ; [#uses = 1, type = i8*]
  %101 = load i8, i8* %100, align 1               ; [#uses = 1]
  %102 = icmp eq i8 %101, 69                      ; [#uses = 1]
  %103 = or i64 %__key243.040.us.i71, 1           ; [#uses = 1]
  %104 = getelementptr inbounds i8, i8* %.ptr1, i64 %103 ; [#uses = 1, type = i8*]
  %105 = load i8, i8* %104, align 1               ; [#uses = 1]
  %106 = icmp eq i8 %105, 69                      ; [#uses = 1]
  %107 = or i1 %106, %102                         ; [#uses = 1]
  %108 = or i64 %__key243.040.us.i71, 2           ; [#uses = 1]
  %109 = getelementptr inbounds i8, i8* %.ptr1, i64 %108 ; [#uses = 1, type = i8*]
  %110 = load i8, i8* %109, align 1               ; [#uses = 1]
  %111 = icmp eq i8 %110, 69                      ; [#uses = 1]
  %112 = or i1 %111, %107                         ; [#uses = 1]
  %113 = or i64 %__key243.040.us.i71, 3           ; [#uses = 1]
  %114 = getelementptr inbounds i8, i8* %.ptr1, i64 %113 ; [#uses = 1, type = i8*]
  %115 = load i8, i8* %114, align 1               ; [#uses = 1]
  %116 = icmp eq i8 %115, 69                      ; [#uses = 1]
  %117 = or i1 %116, %112                         ; [#uses = 1]
  %spec.select98.3 = select i1 %117, i8 1, i8 %99 ; [#uses = 3]
  %118 = add nuw i64 %__key243.040.us.i71, 4      ; [#uses = 2]
  %niter.nsub.3 = add i64 %niter, -4              ; [#uses = 2]
  %niter.ncmp.3 = icmp eq i64 %niter.nsub.3, 0    ; [#uses = 1]
  br i1 %niter.ncmp.3, label %forcond17.preheader.i80.loopexit.unr-lcssa, label %forbody.us.i72

forcond17.preheader.i80.loopexit.unr-lcssa:       ; preds = %forbody.us.i72, %forbody.us.i72.preheader
  %spec.select98.lcssa.ph = phi i8 [ undef, %forbody.us.i72.preheader ], [ %spec.select98.3, %forbody.us.i72 ] ; [#uses = 1, type = i8]
  %.unr = phi i8 [ %.nongc_mem90.promoted, %forbody.us.i72.preheader ], [ %spec.select98.3, %forbody.us.i72 ] ; [#uses = 1, type = i8]
  %__key243.040.us.i71.unr = phi i64 [ 0, %forbody.us.i72.preheader ], [ %118, %forbody.us.i72 ] ; [#uses = 1, type = i64]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0        ; [#uses = 1]
  br i1 %lcmp.mod.not, label %forcond17.preheader.i80.loopexit, label %forbody.us.i72.epil

forbody.us.i72.epil:                              ; preds = %forcond17.preheader.i80.loopexit.unr-lcssa, %forbody.us.i72.epil
  %119 = phi i8 [ %spec.select98.epil, %forbody.us.i72.epil ], [ %.unr, %forcond17.preheader.i80.loopexit.unr-lcssa ] ; [#uses = 1, type = i8]
  %__key243.040.us.i71.epil = phi i64 [ %123, %forbody.us.i72.epil ], [ %__key243.040.us.i71.unr, %forcond17.preheader.i80.loopexit.unr-lcssa ] ; [#uses = 2, type = i64]
  %epil.iter = phi i64 [ %epil.iter.sub, %forbody.us.i72.epil ], [ %xtraiter, %forcond17.preheader.i80.loopexit.unr-lcssa ] ; [#uses = 1, type = i64]
  %120 = getelementptr inbounds i8, i8* %.ptr1, i64 %__key243.040.us.i71.epil ; [#uses = 1, type = i8*]
  %121 = load i8, i8* %120, align 1               ; [#uses = 1]
  %122 = icmp eq i8 %121, 69                      ; [#uses = 1]
  %spec.select98.epil = select i1 %122, i8 1, i8 %119 ; [#uses = 2]
  %123 = add nuw i64 %__key243.040.us.i71.epil, 1 ; [#uses = 1]
  %epil.iter.sub = add i64 %epil.iter, -1         ; [#uses = 2]
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.sub, 0 ; [#uses = 1]
  br i1 %epil.iter.cmp.not, label %forcond17.preheader.i80.loopexit, label %forbody.us.i72.epil, !llvm.loop !21

forcond17.preheader.i80.loopexit:                 ; preds = %forbody.us.i72.epil, %forcond17.preheader.i80.loopexit.unr-lcssa
  %spec.select98.lcssa = phi i8 [ %spec.select98.lcssa.ph, %forcond17.preheader.i80.loopexit.unr-lcssa ], [ %spec.select98.epil, %forbody.us.i72.epil ] ; [#uses = 1, type = i8]
  store i8 %spec.select98.lcssa, i8* %.nongc_mem90, align 1
  br label %forcond17.preheader.i80

forcond17.preheader.i80:                          ; preds = %forcond17.preheader.i80.loopexit, %forcond17.preheader.i60
  %124 = load i8, i8* %.nongc_mem90, align 1, !range !18 ; [#uses = 1]
  %125 = icmp eq i8 %124, 0                       ; [#uses = 1]
  br i1 %125, label %forbody18.i84._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit86_crit_edge, label %forcond17.i82

forcond17.i82:                                    ; preds = %forcond17.preheader.i80
  br i1 %.not99, label %endif, label %else

forbody18.i84._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit86_crit_edge: ; preds = %forcond17.preheader.i80
  br i1 %.not99, label %else, label %endif

else:                                             ; preds = %forcond17.i82, %forbody18.i84._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit86_crit_edge
  br label %endif

endif:                                            ; preds = %forbody18.i44._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit46_crit_edge, %forcond17.i42, %forbody18.i84._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit86_crit_edge, %forcond17.i82, %else
  %.sink = phi { i64, i8* } [ { i64 3, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0) }, %else ], [ { i64 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0) }, %forcond17.i82 ], [ { i64 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0) }, %forbody18.i84._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit86_crit_edge ], [ { i64 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0) }, %forcond17.i42 ], [ { i64 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0) }, %forbody18.i44._D6source__T4haveTaZQiFNaNbNfIAaIQdXb.exit46_crit_edge ] ; [#uses = 1, type = { i64, i8* }]
  call void @_D3std5stdio__T7writelnTAyaZQnFNfQjZv({ i64, i8* } %.sink) #4
  ret i32 0

bounds.fail:                                      ; preds = %forbody.i
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 7, i64 0, i64 0) #3
  unreachable
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D6source2IO__T4lineTAyaVQea1_20ZQsMFmZAQt(%source.IO* nonnull %.this_arg, i64 %m_arg) local_unnamed_addr #2 {
  %arr = alloca { i64, { i64, i8* }* }, align 8   ; [#uses = 4, size/byte = 16]
  %1 = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.not = icmp eq i64 %m_arg, 0                   ; [#uses = 1]
  %2 = bitcast { i64, { i64, i8* }* }* %arr to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %2, i8 0, i64 16, i1 false)
  br i1 %.not, label %endfor, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %0
  %3 = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %4 = bitcast { i64, { i64, i8* }* }* %arr to { i64, i8* }* ; [#uses = 1]
  %5 = bitcast { i64, i8* }** %3 to i8**          ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %forbody, %forbody.lr.ph
  %__key185.011 = phi i64 [ 0, %forbody.lr.ph ], [ %12, %forbody ] ; [#uses = 1, type = i64]
  %6 = call { i64, { i64, i8* }* } @_D6source2IO__T4readTAyaZQkMFQiZAQm(%source.IO* nonnull %.this_arg, { i64, i8* } { i64 1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i32 0, i32 0) }) #4 ; [#uses = 2]
  %7 = extractvalue { i64, { i64, i8* }* } %6, 0  ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %7, 0  ; [#uses = 1]
  %9 = extractvalue { i64, { i64, i8* }* } %6, 1  ; [#uses = 1]
  %10 = bitcast { i64, i8* }* %9 to i8*           ; [#uses = 1]
  %11 = insertvalue { i64, i8* } %8, i8* %10, 1   ; [#uses = 1]
  %.appendedArray = call { i64, i8* } @_d_arrayappendT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), { i64, i8* }* nonnull dereferenceable(16) %4, { i64, i8* } %11) #1 ; [#uses = 4]
  %.len = extractvalue { i64, i8* } %.appendedArray, 0 ; [#uses = 1]
  %.ptr = extractvalue { i64, i8* } %.appendedArray, 1 ; [#uses = 1]
  store i64 %.len, i64* %1, align 8
  store i8* %.ptr, i8** %5, align 8
  %12 = add nuw i64 %__key185.011, 1              ; [#uses = 2]
  %exitcond.not = icmp eq i64 %12, %m_arg         ; [#uses = 1]
  br i1 %exitcond.not, label %endfor.loopexit, label %forbody

endfor.loopexit:                                  ; preds = %forbody
  %.len.le = extractvalue { i64, i8* } %.appendedArray, 0 ; [#uses = 1]
  %.ptr.le = extractvalue { i64, i8* } %.appendedArray, 1 ; [#uses = 1]
  %13 = bitcast i8* %.ptr.le to { i64, i8* }*     ; [#uses = 1]
  br label %endfor

endfor:                                           ; preds = %endfor.loopexit, %0
  %.fca.1.load = phi { i64, i8* }* [ %13, %endfor.loopexit ], [ null, %0 ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load = phi i64 [ %.len.le, %endfor.loopexit ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, { i64, i8* }* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert10 = insertvalue { i64, { i64, i8* }* } %.fca.0.insert, { i64, i8* }* %.fca.1.load, 1 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %.fca.1.insert10
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D6source__T4haveTaZQiFNaNbNfIAaIQdXb({ i64, i8* } %target_arg, { i64, i8* } %args_arg) local_unnamed_addr #2 {
  %args_arg.fca.0.extract = extractvalue { i64, i8* } %args_arg, 0 ; [#uses = 2]
  %args_arg.fca.1.extract = extractvalue { i64, i8* } %args_arg, 1 ; [#uses = 1]
  %target_arg.fca.0.extract = extractvalue { i64, i8* } %target_arg, 0 ; [#uses = 12]
  %target_arg.fca.1.extract = extractvalue { i64, i8* } %target_arg, 1 ; [#uses = 6]
  %.gc_mem = tail call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ab6__initZ to %object.TypeInfo*), i64 %target_arg.fca.0.extract) #1 ; [#uses = 1]
  %.ptr = extractvalue { i64, i8* } %.gc_mem, 1   ; [#uses = 14]
  %.not = icmp eq i64 %args_arg.fca.0.extract, 0  ; [#uses = 1]
  br i1 %.not, label %forcond17.preheader, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %0
  %.not42 = icmp eq i64 %target_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not42, label %if23, label %forbody.us.preheader

forbody.us.preheader:                             ; preds = %forbody.lr.ph
  %scevgep = getelementptr i8, i8* %.ptr, i64 %target_arg.fca.0.extract ; [#uses = 1, type = i8*]
  %scevgep47 = getelementptr i8, i8* %target_arg.fca.1.extract, i64 %target_arg.fca.0.extract ; [#uses = 1, type = i8*]
  %min.iters.check = icmp ult i64 %target_arg.fca.0.extract, 8 ; [#uses = 1]
  %bound0 = icmp ult i8* %.ptr, %scevgep47        ; [#uses = 1]
  %bound1 = icmp ult i8* %target_arg.fca.1.extract, %scevgep ; [#uses = 1]
  %found.conflict = and i1 %bound0, %bound1       ; [#uses = 1]
  %n.vec = and i64 %target_arg.fca.0.extract, -8  ; [#uses = 3]
  %cmp.n = icmp eq i64 %target_arg.fca.0.extract, %n.vec ; [#uses = 1]
  %xtraiter = and i64 %target_arg.fca.0.extract, 1 ; [#uses = 1]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0        ; [#uses = 1]
  br label %forbody.us

forbody.us:                                       ; preds = %forbody.us.preheader, %forcond7.forinc_crit_edge.us
  %__key243.040.us = phi i64 [ %44, %forcond7.forinc_crit_edge.us ], [ 0, %forbody.us.preheader ] ; [#uses = 2, type = i64]
  %1 = getelementptr inbounds i8, i8* %args_arg.fca.1.extract, i64 %__key243.040.us ; [#uses = 1, type = i8*]
  %2 = load i8, i8* %1, align 1                   ; [#uses = 4]
  %brmerge = or i1 %min.iters.check, %found.conflict ; [#uses = 1]
  br i1 %brmerge, label %forbody8.us.preheader, label %vector.ph

vector.ph:                                        ; preds = %forbody.us
  %broadcast.splatinsert = insertelement <8 x i8> undef, i8 %2, i32 0 ; [#uses = 1]
  %broadcast.splat = shufflevector <8 x i8> %broadcast.splatinsert, <8 x i8> undef, <8 x i32> zeroinitializer ; [#uses = 1]
  br label %vector.body

vector.body:                                      ; preds = %pred.store.continue61, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %pred.store.continue61 ] ; [#uses = 10, type = i64]
  %3 = getelementptr inbounds i8, i8* %target_arg.fca.1.extract, i64 %index ; [#uses = 1, type = i8*]
  %4 = bitcast i8* %3 to <8 x i8>*                ; [#uses = 1]
  %wide.load = load <8 x i8>, <8 x i8>* %4, align 1, !alias.scope !22 ; [#uses = 1]
  %5 = icmp eq <8 x i8> %broadcast.splat, %wide.load ; [#uses = 8]
  %6 = extractelement <8 x i1> %5, i32 0          ; [#uses = 1]
  br i1 %6, label %pred.store.if, label %pred.store.continue

pred.store.if:                                    ; preds = %vector.body
  %7 = getelementptr inbounds i8, i8* %.ptr, i64 %index ; [#uses = 1, type = i8*]
  store i8 1, i8* %7, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue

pred.store.continue:                              ; preds = %pred.store.if, %vector.body
  %8 = extractelement <8 x i1> %5, i32 1          ; [#uses = 1]
  br i1 %8, label %pred.store.if48, label %pred.store.continue49

pred.store.if48:                                  ; preds = %pred.store.continue
  %9 = or i64 %index, 1                           ; [#uses = 1]
  %10 = getelementptr inbounds i8, i8* %.ptr, i64 %9 ; [#uses = 1, type = i8*]
  store i8 1, i8* %10, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue49

pred.store.continue49:                            ; preds = %pred.store.if48, %pred.store.continue
  %11 = extractelement <8 x i1> %5, i32 2         ; [#uses = 1]
  br i1 %11, label %pred.store.if50, label %pred.store.continue51

pred.store.if50:                                  ; preds = %pred.store.continue49
  %12 = or i64 %index, 2                          ; [#uses = 1]
  %13 = getelementptr inbounds i8, i8* %.ptr, i64 %12 ; [#uses = 1, type = i8*]
  store i8 1, i8* %13, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue51

pred.store.continue51:                            ; preds = %pred.store.if50, %pred.store.continue49
  %14 = extractelement <8 x i1> %5, i32 3         ; [#uses = 1]
  br i1 %14, label %pred.store.if52, label %pred.store.continue53

pred.store.if52:                                  ; preds = %pred.store.continue51
  %15 = or i64 %index, 3                          ; [#uses = 1]
  %16 = getelementptr inbounds i8, i8* %.ptr, i64 %15 ; [#uses = 1, type = i8*]
  store i8 1, i8* %16, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue53

pred.store.continue53:                            ; preds = %pred.store.if52, %pred.store.continue51
  %17 = extractelement <8 x i1> %5, i32 4         ; [#uses = 1]
  br i1 %17, label %pred.store.if54, label %pred.store.continue55

pred.store.if54:                                  ; preds = %pred.store.continue53
  %18 = or i64 %index, 4                          ; [#uses = 1]
  %19 = getelementptr inbounds i8, i8* %.ptr, i64 %18 ; [#uses = 1, type = i8*]
  store i8 1, i8* %19, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue55

pred.store.continue55:                            ; preds = %pred.store.if54, %pred.store.continue53
  %20 = extractelement <8 x i1> %5, i32 5         ; [#uses = 1]
  br i1 %20, label %pred.store.if56, label %pred.store.continue57

pred.store.if56:                                  ; preds = %pred.store.continue55
  %21 = or i64 %index, 5                          ; [#uses = 1]
  %22 = getelementptr inbounds i8, i8* %.ptr, i64 %21 ; [#uses = 1, type = i8*]
  store i8 1, i8* %22, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue57

pred.store.continue57:                            ; preds = %pred.store.if56, %pred.store.continue55
  %23 = extractelement <8 x i1> %5, i32 6         ; [#uses = 1]
  br i1 %23, label %pred.store.if58, label %pred.store.continue59

pred.store.if58:                                  ; preds = %pred.store.continue57
  %24 = or i64 %index, 6                          ; [#uses = 1]
  %25 = getelementptr inbounds i8, i8* %.ptr, i64 %24 ; [#uses = 1, type = i8*]
  store i8 1, i8* %25, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue59

pred.store.continue59:                            ; preds = %pred.store.if58, %pred.store.continue57
  %26 = extractelement <8 x i1> %5, i32 7         ; [#uses = 1]
  br i1 %26, label %pred.store.if60, label %pred.store.continue61

pred.store.if60:                                  ; preds = %pred.store.continue59
  %27 = or i64 %index, 7                          ; [#uses = 1]
  %28 = getelementptr inbounds i8, i8* %.ptr, i64 %27 ; [#uses = 1, type = i8*]
  store i8 1, i8* %28, align 1, !alias.scope !25, !noalias !22
  br label %pred.store.continue61

pred.store.continue61:                            ; preds = %pred.store.if60, %pred.store.continue59
  %index.next = add i64 %index, 8                 ; [#uses = 2]
  %29 = icmp eq i64 %index.next, %n.vec           ; [#uses = 1]
  br i1 %29, label %middle.block, label %vector.body, !llvm.loop !27

middle.block:                                     ; preds = %pred.store.continue61
  br i1 %cmp.n, label %forcond7.forinc_crit_edge.us, label %forbody8.us.preheader

forbody8.us.preheader:                            ; preds = %forbody.us, %middle.block
  %__key244.038.us.ph = phi i64 [ 0, %forbody.us ], [ %n.vec, %middle.block ] ; [#uses = 5, type = i64]
  %.neg = or i64 %__key244.038.us.ph, 1           ; [#uses = 1]
  br i1 %lcmp.mod.not, label %forbody8.us.prol.loopexit, label %forbody8.us.prol

forbody8.us.prol:                                 ; preds = %forbody8.us.preheader
  %30 = getelementptr inbounds i8, i8* %target_arg.fca.1.extract, i64 %__key244.038.us.ph ; [#uses = 1, type = i8*]
  %31 = load i8, i8* %30, align 1                 ; [#uses = 1]
  %32 = icmp eq i8 %2, %31                        ; [#uses = 1]
  br i1 %32, label %bounds.ok.us.prol, label %forinc9.us.prol

bounds.ok.us.prol:                                ; preds = %forbody8.us.prol
  %33 = getelementptr inbounds i8, i8* %.ptr, i64 %__key244.038.us.ph ; [#uses = 1, type = i8*]
  store i8 1, i8* %33, align 1
  br label %forinc9.us.prol

forinc9.us.prol:                                  ; preds = %bounds.ok.us.prol, %forbody8.us.prol
  %34 = or i64 %__key244.038.us.ph, 1             ; [#uses = 1]
  br label %forbody8.us.prol.loopexit

forbody8.us.prol.loopexit:                        ; preds = %forinc9.us.prol, %forbody8.us.preheader
  %__key244.038.us.unr.ph = phi i64 [ %34, %forinc9.us.prol ], [ %__key244.038.us.ph, %forbody8.us.preheader ] ; [#uses = 1, type = i64]
  %35 = icmp eq i64 %target_arg.fca.0.extract, %.neg ; [#uses = 1]
  br i1 %35, label %forcond7.forinc_crit_edge.us, label %forbody8.us

forbody8.us:                                      ; preds = %forbody8.us.prol.loopexit, %forinc9.us.1
  %__key244.038.us = phi i64 [ %50, %forinc9.us.1 ], [ %__key244.038.us.unr.ph, %forbody8.us.prol.loopexit ] ; [#uses = 4, type = i64]
  %36 = getelementptr inbounds i8, i8* %target_arg.fca.1.extract, i64 %__key244.038.us ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %38 = icmp eq i8 %2, %37                        ; [#uses = 1]
  br i1 %38, label %bounds.ok.us, label %forinc9.us

bounds.ok.us:                                     ; preds = %forbody8.us
  %39 = getelementptr inbounds i8, i8* %.ptr, i64 %__key244.038.us ; [#uses = 1, type = i8*]
  store i8 1, i8* %39, align 1
  br label %forinc9.us

forinc9.us:                                       ; preds = %bounds.ok.us, %forbody8.us
  %40 = add nuw i64 %__key244.038.us, 1           ; [#uses = 2]
  %41 = getelementptr inbounds i8, i8* %target_arg.fca.1.extract, i64 %40 ; [#uses = 1, type = i8*]
  %42 = load i8, i8* %41, align 1                 ; [#uses = 1]
  %43 = icmp eq i8 %2, %42                        ; [#uses = 1]
  br i1 %43, label %bounds.ok.us.1, label %forinc9.us.1

forcond7.forinc_crit_edge.us:                     ; preds = %forbody8.us.prol.loopexit, %forinc9.us.1, %middle.block
  %44 = add nuw i64 %__key243.040.us, 1           ; [#uses = 2]
  %exitcond45.not = icmp eq i64 %44, %args_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond45.not, label %forcond17.preheader, label %forbody.us

forcond17.preheader:                              ; preds = %forcond7.forinc_crit_edge.us, %0
  %.not41 = icmp eq i64 %target_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not41, label %if23, label %forbody18

forcond17:                                        ; preds = %forbody18
  %exitcond.not = icmp eq i64 %48, %target_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %if23, label %forbody18

forbody18:                                        ; preds = %forcond17.preheader, %forcond17
  %__key247.036 = phi i64 [ %48, %forcond17 ], [ 0, %forcond17.preheader ] ; [#uses = 2, type = i64]
  %45 = getelementptr inbounds i8, i8* %.ptr, i64 %__key247.036 ; [#uses = 1, type = i8*]
  %46 = load i8, i8* %45, align 1, !range !18     ; [#uses = 1]
  %47 = icmp eq i8 %46, 0                         ; [#uses = 1]
  %48 = add nuw i64 %__key247.036, 1              ; [#uses = 2]
  br i1 %47, label %if23, label %forcond17

if23:                                             ; preds = %forbody18, %forcond17, %forbody.lr.ph, %forcond17.preheader
  %merge = phi i1 [ true, %forcond17.preheader ], [ true, %forbody.lr.ph ], [ true, %forcond17 ], [ false, %forbody18 ] ; [#uses = 1, type = i1]
  ret i1 %merge

bounds.ok.us.1:                                   ; preds = %forinc9.us
  %49 = getelementptr inbounds i8, i8* %.ptr, i64 %40 ; [#uses = 1, type = i8*]
  store i8 1, i8* %49, align 1
  br label %forinc9.us.1

forinc9.us.1:                                     ; preds = %bounds.ok.us.1, %forinc9.us
  %50 = add nuw i64 %__key244.038.us, 2           ; [#uses = 2]
  %exitcond44.not.1 = icmp eq i64 %50, %target_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond44.not.1, label %forcond7.forinc_crit_edge.us, label %forbody8.us, !llvm.loop !29
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio__T7writelnTAyaZQnFNfQjZv({ i64, i8* } %_param_0_arg) local_unnamed_addr #2 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %w = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 9, size/byte = 48]
  %__tmpfordtor249 = alloca %std.stdio.File, align 8 ; [#uses = 4, size/byte = 24]
  call void @_D3std5stdio13trustedStdoutFNdNeZSQBgQBf4File(%std.stdio.File* noalias nonnull sret align 8 %__tmpfordtor249) #4
  invoke void @_D3std5stdio4File17lockingTextWriterMFNfZSQBoQBnQBk17LockingTextWriter(%std.stdio.File.LockingTextWriter* noalias nonnull sret align 8 %w, %std.stdio.File* nonnull %__tmpfordtor249) #4
          to label %toElem.success unwind label %dtor.__tmpfordtor249

toElem.success:                                   ; preds = %0
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor249) #4
  %writeme_arg.fca.0.extract.i = extractvalue { i64, i8* } %_param_0_arg, 0 ; [#uses = 4]
  %writeme_arg.fca.1.extract.i = extractvalue { i64, i8* } %_param_0_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, i64 0, i32 1 ; [#uses = 2, type = i32*]
  %2 = load i32, i32* %1, align 8                 ; [#uses = 1]
  %3 = icmp slt i32 %2, 1                         ; [#uses = 1]
  br i1 %3, label %if.i, label %forcond.preheader.i

forcond.preheader.i:                              ; preds = %toElem.success
  %.not11.i = icmp eq i64 %writeme_arg.fca.0.extract.i, 0 ; [#uses = 1]
  br i1 %.not11.i, label %postinvoke2, label %forbody.i

if.i:                                             ; preds = %toElem.success
  %4 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %w, 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 = call i64 @fwrite(i8* %writeme_arg.fca.1.extract.i, i64 1, i64 %writeme_arg.fca.0.extract.i, %core.stdc.stdio._IO_FILE* %7) #4 ; [#uses = 1]
  %.not.i = icmp eq i64 %8, %writeme_arg.fca.0.extract.i ; [#uses = 1]
  br i1 %.not.i, label %postinvoke2, label %if1.i

if1.i:                                            ; preds = %if.i
  invoke void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } zeroinitializer, i64 3263, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.10, i32 0, i32 0) }) #13
          to label %.noexc unwind label %finally.loopexit.split-lp

.noexc:                                           ; preds = %if1.i
  unreachable

forbody.i:                                        ; preds = %forcond.preheader.i, %.noexc5
  %__key252.010.i = phi i64 [ %11, %.noexc5 ], [ 0, %forcond.preheader.i ] ; [#uses = 2, type = i64]
  %9 = getelementptr inbounds i8, i8* %writeme_arg.fca.1.extract.i, i64 %__key252.010.i ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTyaZQiMFNfyaZv(%std.stdio.File.LockingTextWriter* nonnull %w, i8 zeroext %10) #4
          to label %.noexc5 unwind label %finally.loopexit

.noexc5:                                          ; preds = %forbody.i
  %11 = add nuw i64 %__key252.010.i, 1            ; [#uses = 2]
  %exitcond.not.i = icmp eq i64 %11, %writeme_arg.fca.0.extract.i ; [#uses = 1]
  br i1 %exitcond.not.i, label %postinvoke2, label %forbody.i

postinvoke2:                                      ; preds = %.noexc5, %if.i, %forcond.preheader.i
  invoke void @_D3std5stdio4File17LockingTextWriter26highSurrogateShouldBeEmptyMFNfZv(%std.stdio.File.LockingTextWriter* nonnull %w) #4
          to label %.noexc8 unwind label %finally.loopexit.split-lp

.noexc8:                                          ; preds = %postinvoke2
  %12 = load i32, i32* %1, align 8                ; [#uses = 1]
  %13 = icmp slt i32 %12, 1                       ; [#uses = 1]
  br i1 %13, label %if.i6, label %else.i

if.i6:                                            ; preds = %.noexc8
  %14 = invoke %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %w) #4
          to label %.noexc9 unwind label %finally.loopexit.split-lp ; [#uses = 1]

.noexc9:                                          ; preds = %if.i6
  %15 = call i32 @fputc_unlocked(i32 10, %core.stdc.stdio._IO_FILE* %14) #4 ; [#uses = 0]
  br label %try.success

else.i:                                           ; preds = %.noexc8
  %16 = invoke %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %w) #4
          to label %.noexc10 unwind label %finally.loopexit.split-lp ; [#uses = 1]

.noexc10:                                         ; preds = %else.i
  %17 = invoke i32 @fputwc_unlocked(i32 10, %core.stdc.stdio._IO_FILE* %16) #4
          to label %try.success unwind label %finally.loopexit.split-lp ; [#uses = 0]

finally.loopexit:                                 ; preds = %forbody.i
  %lpad.loopexit = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  br label %finally

finally.loopexit.split-lp:                        ; preds = %.noexc10, %else.i, %if.i6, %postinvoke2, %if1.i
  %lpad.loopexit.split-lp = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  br label %finally

finally:                                          ; preds = %finally.loopexit.split-lp, %finally.loopexit
  %lpad.phi = phi { i8*, i32 } [ %lpad.loopexit, %finally.loopexit ], [ %lpad.loopexit.split-lp, %finally.loopexit.split-lp ] ; [#uses = 1, type = { i8*, i32 }]
  %18 = extractvalue { i8*, i32 } %lpad.phi, 0    ; [#uses = 1]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #4
  br label %eh.resume

try.success:                                      ; preds = %.noexc10, %.noexc9
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #4
  ret void

dtor.__tmpfordtor249:                             ; preds = %0
  %19 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %20 = extractvalue { i8*, i32 } %19, 0          ; [#uses = 1]
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor249) #4
  br label %eh.resume

eh.resume:                                        ; preds = %dtor.__tmpfordtor249, %finally
  %eh.ptr.2 = phi i8* [ %18, %finally ], [ %20, %dtor.__tmpfordtor249 ] ; [#uses = 1, type = i8*]
  call void @_Unwind_Resume(i8* %eh.ptr.2)
  unreachable
}

; [#uses = 1]
declare { i64, i8* } @_D6object6Object8toStringMFZAya(%object.Object* nonnull) #4

; [#uses = 1]
declare i64 @_D6object6Object6toHashMFNbNeZm(%object.Object* nonnull) #4

; [#uses = 1]
declare i32 @_D6object6Object5opCmpMFCQqZi(%object.Object* nonnull, %object.Object*) #4

; [#uses = 1]
declare zeroext i1 @_D6object6Object8opEqualsMFCQtZb(%object.Object* nonnull, %object.Object*) #4

; [#uses = 0]
; Function Attrs: norecurse nounwind readonly uwtable
define x86_fp80 @_D6source5multiFNaIAeZe({ i64, x86_fp80* } %args_arg) local_unnamed_addr #5 {
  %args_arg.fca.0.extract = extractvalue { i64, x86_fp80* } %args_arg, 0 ; [#uses = 4]
  %args_arg.fca.1.extract = extractvalue { i64, x86_fp80* } %args_arg, 1 ; [#uses = 5]
  %.not = icmp eq i64 %args_arg.fca.0.extract, 0  ; [#uses = 1]
  br i1 %.not, label %endfor, label %bounds.ok.preheader

bounds.ok.preheader:                              ; preds = %0
  %1 = add i64 %args_arg.fca.0.extract, -1        ; [#uses = 1]
  %xtraiter = and i64 %args_arg.fca.0.extract, 3  ; [#uses = 2]
  %2 = icmp ult i64 %1, 3                         ; [#uses = 1]
  br i1 %2, label %endfor.loopexit.unr-lcssa, label %bounds.ok.preheader.new

bounds.ok.preheader.new:                          ; preds = %bounds.ok.preheader
  %unroll_iter = and i64 %args_arg.fca.0.extract, -4 ; [#uses = 1]
  br label %bounds.ok

bounds.ok:                                        ; preds = %bounds.ok, %bounds.ok.preheader.new
  %ret.09 = phi x86_fp80 [ 0xK3FFF8000000000000000, %bounds.ok.preheader.new ], [ %17, %bounds.ok ] ; [#uses = 1, type = x86_fp80]
  %__key261.08 = phi i64 [ 0, %bounds.ok.preheader.new ], [ %18, %bounds.ok ] ; [#uses = 5, type = i64]
  %niter = phi i64 [ %unroll_iter, %bounds.ok.preheader.new ], [ %niter.nsub.3, %bounds.ok ] ; [#uses = 1, type = i64]
  %3 = getelementptr inbounds x86_fp80, x86_fp80* %args_arg.fca.1.extract, i64 %__key261.08 ; [#uses = 1, type = x86_fp80*]
  %4 = load x86_fp80, x86_fp80* %3, align 16      ; [#uses = 1]
  %5 = fmul x86_fp80 %ret.09, %4                  ; [#uses = 1]
  %6 = or i64 %__key261.08, 1                     ; [#uses = 1]
  %7 = getelementptr inbounds x86_fp80, x86_fp80* %args_arg.fca.1.extract, i64 %6 ; [#uses = 1, type = x86_fp80*]
  %8 = load x86_fp80, x86_fp80* %7, align 16      ; [#uses = 1]
  %9 = fmul x86_fp80 %5, %8                       ; [#uses = 1]
  %10 = or i64 %__key261.08, 2                    ; [#uses = 1]
  %11 = getelementptr inbounds x86_fp80, x86_fp80* %args_arg.fca.1.extract, i64 %10 ; [#uses = 1, type = x86_fp80*]
  %12 = load x86_fp80, x86_fp80* %11, align 16    ; [#uses = 1]
  %13 = fmul x86_fp80 %9, %12                     ; [#uses = 1]
  %14 = or i64 %__key261.08, 3                    ; [#uses = 1]
  %15 = getelementptr inbounds x86_fp80, x86_fp80* %args_arg.fca.1.extract, i64 %14 ; [#uses = 1, type = x86_fp80*]
  %16 = load x86_fp80, x86_fp80* %15, align 16    ; [#uses = 1]
  %17 = fmul x86_fp80 %13, %16                    ; [#uses = 3]
  %18 = add nuw i64 %__key261.08, 4               ; [#uses = 2]
  %niter.nsub.3 = add i64 %niter, -4              ; [#uses = 2]
  %niter.ncmp.3 = icmp eq i64 %niter.nsub.3, 0    ; [#uses = 1]
  br i1 %niter.ncmp.3, label %endfor.loopexit.unr-lcssa, label %bounds.ok

endfor.loopexit.unr-lcssa:                        ; preds = %bounds.ok, %bounds.ok.preheader
  %.lcssa.ph = phi x86_fp80 [ undef, %bounds.ok.preheader ], [ %17, %bounds.ok ] ; [#uses = 1, type = x86_fp80]
  %ret.09.unr = phi x86_fp80 [ 0xK3FFF8000000000000000, %bounds.ok.preheader ], [ %17, %bounds.ok ] ; [#uses = 1, type = x86_fp80]
  %__key261.08.unr = phi i64 [ 0, %bounds.ok.preheader ], [ %18, %bounds.ok ] ; [#uses = 1, type = i64]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0        ; [#uses = 1]
  br i1 %lcmp.mod.not, label %endfor, label %bounds.ok.epil

bounds.ok.epil:                                   ; preds = %endfor.loopexit.unr-lcssa, %bounds.ok.epil
  %ret.09.epil = phi x86_fp80 [ %21, %bounds.ok.epil ], [ %ret.09.unr, %endfor.loopexit.unr-lcssa ] ; [#uses = 1, type = x86_fp80]
  %__key261.08.epil = phi i64 [ %22, %bounds.ok.epil ], [ %__key261.08.unr, %endfor.loopexit.unr-lcssa ] ; [#uses = 2, type = i64]
  %epil.iter = phi i64 [ %epil.iter.sub, %bounds.ok.epil ], [ %xtraiter, %endfor.loopexit.unr-lcssa ] ; [#uses = 1, type = i64]
  %19 = getelementptr inbounds x86_fp80, x86_fp80* %args_arg.fca.1.extract, i64 %__key261.08.epil ; [#uses = 1, type = x86_fp80*]
  %20 = load x86_fp80, x86_fp80* %19, align 16    ; [#uses = 1]
  %21 = fmul x86_fp80 %ret.09.epil, %20           ; [#uses = 2]
  %22 = add nuw i64 %__key261.08.epil, 1          ; [#uses = 1]
  %epil.iter.sub = add i64 %epil.iter, -1         ; [#uses = 2]
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.sub, 0 ; [#uses = 1]
  br i1 %epil.iter.cmp.not, label %endfor, label %bounds.ok.epil, !llvm.loop !30

endfor:                                           ; preds = %endfor.loopexit.unr-lcssa, %bounds.ok.epil, %0
  %ret.0.lcssa = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %.lcssa.ph, %endfor.loopexit.unr-lcssa ], [ %21, %bounds.ok.epil ] ; [#uses = 1, type = x86_fp80]
  ret x86_fp80 %ret.0.lcssa
}

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

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D6source2IO__T4readTAyaZQkMFQiZAQm(%source.IO* nonnull %.this_arg, { i64, i8* } %token_arg) local_unnamed_addr #2 {
  %.sret_tmp.i = alloca %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", align 8 ; [#uses = 7, size/byte = 40]
  %arr = alloca { i64, { i64, i8* }* }, align 8   ; [#uses = 4, size/byte = 16]
  %.fca.0.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.fca.1.gep = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr, i64 0, i32 1 ; [#uses = 2, type = { i64, i8* }**]
  %1 = bitcast { i64, { i64, i8* }* }* %arr to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %1, i8 0, i64 16, i1 false)
  %2 = tail call { i64, i8* } @_D3std5stdio__T6readlnTAyaZQmFwZQj(i32 10) #4 ; [#uses = 1]
  %3 = tail call { i64, i8* } @_D3std6string__T5chompTAyaZQlFNaNbNiNfQpZQs({ i64, i8* } %2) #4 ; [#uses = 2]
  %4 = bitcast %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i to i8* ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 40, i8* nonnull %4)
  %.repack.i.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.repack3.i.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.repack4.i.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.repack5.i.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %5 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp.i, i64 0, i32 2 ; [#uses = 1, type = i64*]
  store i64 -1, i64* %5, align 8, !alias.scope !31
  %input_arg.fca.0.extract.i.i.i = extractvalue { i64, i8* } %3, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i.i.i = extractvalue { i64, i8* } %3, 1 ; [#uses = 1]
  %separator_arg.fca.0.extract.i.i.i = extractvalue { i64, i8* } %token_arg, 0 ; [#uses = 1]
  %separator_arg.fca.1.extract.i.i.i = extractvalue { i64, i8* } %token_arg, 1 ; [#uses = 1]
  store i64 %input_arg.fca.0.extract.i.i.i, i64* %.repack.i.i, align 8, !alias.scope !31
  store i8* %input_arg.fca.1.extract.i.i.i, i8** %.repack3.i.i, align 8, !alias.scope !31
  store i64 %separator_arg.fca.0.extract.i.i.i, i64* %.repack4.i.i, align 8, !alias.scope !31
  store i8* %separator_arg.fca.1.extract.i.i.i, i8** %.repack5.i.i, align 8, !alias.scope !31
  %6 = tail call { i64, { i64, i8* }* } @_D3std5array__TQjTSQr9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCu8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6ResultZQGcFNaNbNfQGaZAQEv(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull byval align 8 %.sret_tmp.i) #4 ; [#uses = 2]
  call void @llvm.lifetime.end.p0i8(i64 40, i8* nonnull %4)
  %.ptr = extractvalue { i64, { i64, i8* }* } %6, 1 ; [#uses = 1]
  %.len = extractvalue { i64, { i64, i8* }* } %6, 0 ; [#uses = 2]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %0
  %7 = bitcast { i64, { i64, i8* }* }* %arr to { i64, i8* }* ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %forbody, %forbody.lr.ph
  %__key238.028 = phi i64 [ 0, %forbody.lr.ph ], [ %13, %forbody ] ; [#uses = 2, type = i64]
  %8 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr, i64 %__key238.028, i32 0 ; [#uses = 1, type = i64*]
  %9 = bitcast i64* %8 to <2 x i64>*              ; [#uses = 1]
  %10 = load <2 x i64>, <2 x i64>* %9, align 8    ; [#uses = 1]
  %.appendedArray = call { i64, i8* } @_d_arrayappendcTX(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), { i64, i8* }* nonnull dereferenceable(16) %7, i64 1) #1 ; [#uses = 0]
  %.len5 = load i64, i64* %.fca.0.gep, align 8    ; [#uses = 1]
  %.ptr6 = load { i64, i8* }*, { i64, i8* }** %.fca.1.gep, align 8 ; [#uses = 1]
  %.lastIndex = add i64 %.len5, -1                ; [#uses = 1]
  %11 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr6, i64 %.lastIndex, i32 0 ; [#uses = 1, type = i64*]
  %12 = bitcast i64* %11 to <2 x i64>*            ; [#uses = 1]
  store <2 x i64> %10, <2 x i64>* %12, align 8
  %13 = add nuw i64 %__key238.028, 1              ; [#uses = 2]
  %exitcond.not = icmp eq i64 %13, %.len          ; [#uses = 1]
  br i1 %exitcond.not, label %endfor.loopexit, label %forbody

endfor.loopexit:                                  ; preds = %forbody
  %.fca.0.load.pre = load i64, i64* %.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.1.load.pre = load { i64, i8* }*, { i64, i8* }** %.fca.1.gep, align 8 ; [#uses = 1]
  br label %endfor

endfor:                                           ; preds = %endfor.loopexit, %0
  %.fca.1.load = phi { i64, i8* }* [ %.fca.1.load.pre, %endfor.loopexit ], [ null, %0 ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %endfor.loopexit ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.fca.0.insert12 = insertvalue { i64, { i64, i8* }* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert20 = insertvalue { i64, { i64, i8* }* } %.fca.0.insert12, { i64, i8* }* %.fca.1.load, 1 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %.fca.1.insert20
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__T5splitTAyaTQeZQoFNaNbNfQqQsZAQw({ i64, i8* } %sep_arg, { i64, i8* } %range_arg) local_unnamed_addr #2 {
  %.sret_tmp = alloca %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", align 8 ; [#uses = 6, size/byte = 40]
  %.repack.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.repack3.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.repack4.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.repack5.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_tmp, i64 0, i32 2 ; [#uses = 1, type = i64*]
  store i64 -1, i64* %1, align 8, !alias.scope !34
  %input_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %range_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i.i = extractvalue { i64, i8* } %range_arg, 1 ; [#uses = 1]
  %separator_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %sep_arg, 0 ; [#uses = 1]
  %separator_arg.fca.1.extract.i.i = extractvalue { i64, i8* } %sep_arg, 1 ; [#uses = 1]
  store i64 %input_arg.fca.0.extract.i.i, i64* %.repack.i, align 8, !alias.scope !34
  store i8* %input_arg.fca.1.extract.i.i, i8** %.repack3.i, align 8, !alias.scope !34
  store i64 %separator_arg.fca.0.extract.i.i, i64* %.repack4.i, align 8, !alias.scope !34
  store i8* %separator_arg.fca.1.extract.i.i, i8** %.repack5.i, align 8, !alias.scope !34
  %2 = tail call { i64, { i64, i8* }* } @_D3std5array__TQjTSQr9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCu8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6ResultZQGcFNaNbNfQGaZAQEv(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull byval align 8 %.sret_tmp) #4 ; [#uses = 1]
  ret { i64, { i64, i8* }* } %2
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std6string__T5chompTAyaZQlFNaNbNiNfQpZQs({ i64, i8* } %str_arg) local_unnamed_addr #2 {
  %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 = 9]
  %.not.i = icmp eq i64 %str_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not.i, label %if, label %bounds.ok78

if:                                               ; preds = %case22, %bounds.ok29, %bounds.ok38, %case52, %andand54, %bounds.ok78, %0
  ret { i64, i8* } %str_arg

bounds.ok78:                                      ; preds = %0
  %1 = add i64 %str_arg.fca.0.extract, -1         ; [#uses = 2]
  %2 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %1 ; [#uses = 1, type = i8*]
  %3 = load i8, i8* %2, align 1                   ; [#uses = 1]
  switch i8 %3, label %if [
    i8 10, label %case
    i8 13, label %bounds.ok14
    i8 11, label %bounds.ok14
    i8 12, label %bounds.ok14
    i8 -88, label %case22
    i8 -87, label %case22
    i8 -123, label %case52
  ]

case:                                             ; preds = %bounds.ok78
  %4 = icmp ugt i64 %str_arg.fca.0.extract, 1     ; [#uses = 1]
  br i1 %4, label %andand, label %bounds.ok14

andand:                                           ; preds = %case
  %5 = add i64 %str_arg.fca.0.extract, -2         ; [#uses = 2]
  %6 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %5 ; [#uses = 1, type = i8*]
  %7 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %8 = icmp eq i8 %7, 13                          ; [#uses = 1]
  br i1 %8, label %bounds.ok6, label %bounds.ok14

bounds.ok6:                                       ; preds = %andand
  %9 = insertvalue { i64, i8* } undef, i64 %5, 0  ; [#uses = 1]
  %10 = insertvalue { i64, i8* } %9, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %10

bounds.ok14:                                      ; preds = %bounds.ok78, %case, %andand, %bounds.ok78, %bounds.ok78
  %11 = insertvalue { i64, i8* } undef, i64 %1, 0 ; [#uses = 1]
  %12 = insertvalue { i64, i8* } %11, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %12

case22:                                           ; preds = %bounds.ok78, %bounds.ok78
  %13 = icmp ugt i64 %str_arg.fca.0.extract, 2    ; [#uses = 1]
  br i1 %13, label %bounds.ok29, label %if

bounds.ok29:                                      ; preds = %case22
  %14 = add i64 %str_arg.fca.0.extract, -2        ; [#uses = 1]
  %15 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %14 ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %17 = icmp eq i8 %16, -128                      ; [#uses = 1]
  br i1 %17, label %bounds.ok38, label %if

bounds.ok38:                                      ; preds = %bounds.ok29
  %18 = add i64 %str_arg.fca.0.extract, -3        ; [#uses = 2]
  %19 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %18 ; [#uses = 1, type = i8*]
  %20 = load i8, i8* %19, align 1                 ; [#uses = 1]
  %21 = icmp eq i8 %20, -30                       ; [#uses = 1]
  br i1 %21, label %bounds.ok45, label %if

bounds.ok45:                                      ; preds = %bounds.ok38
  %22 = insertvalue { i64, i8* } undef, i64 %18, 0 ; [#uses = 1]
  %23 = insertvalue { i64, i8* } %22, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %23

case52:                                           ; preds = %bounds.ok78
  %24 = icmp ugt i64 %str_arg.fca.0.extract, 1    ; [#uses = 1]
  br i1 %24, label %andand54, label %if

andand54:                                         ; preds = %case52
  %25 = add i64 %str_arg.fca.0.extract, -2        ; [#uses = 2]
  %26 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %25 ; [#uses = 1, type = i8*]
  %27 = load i8, i8* %26, align 1                 ; [#uses = 1]
  %28 = icmp eq i8 %27, -62                       ; [#uses = 1]
  br i1 %28, label %bounds.ok66, label %if

bounds.ok66:                                      ; preds = %andand54
  %29 = insertvalue { i64, i8* } undef, i64 %25, 0 ; [#uses = 1]
  %30 = insertvalue { i64, i8* } %29, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %30
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5stdio__T6readlnTAyaZQmFwZQj(i32 %terminator_arg) local_unnamed_addr #2 {
  %buf.i = alloca { i64, i8* }, align 8           ; [#uses = 4, size/byte = 16]
  %1 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #4 ; [#uses = 1]
  %2 = bitcast { i64, i8* }* %buf.i to i8*        ; [#uses = 3]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %2)
  %3 = getelementptr inbounds %std.stdio.File, %std.stdio.File* %1, i64 0, i32 0 ; [#uses = 4, type = %std.stdio.File.Impl**]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %2, i8 0, i64 16, i1 false)
  %4 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %3, align 8 ; [#uses = 3]
  %.not.i.i = icmp eq %std.stdio.File.Impl* %4, null ; [#uses = 1]
  br i1 %.not.i.i, label %if.i.i.i, label %andandend.i.i

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

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

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

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

if1.i.i:                                          ; preds = %if.i.i
  %12 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %3, 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 1, i32* %13, align 4
  br label %_D3std5stdio4File__T6readlnTAyaZQmMFwZQk.exit

else.i.i:                                         ; preds = %if.i.i
  %.not7.i.i = icmp eq i32 %10, 0                 ; [#uses = 1]
  br i1 %.not7.i.i, label %_D3std5stdio4File__T6readlnTAyaZQmMFwZQk.exit, label %if3.i.i

if3.i.i:                                          ; preds = %else.i.i
  %14 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %3, align 8 ; [#uses = 1]
  %15 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %14, i64 0, i32 4 ; [#uses = 1, type = i32*]
  store i32 2, i32* %15, align 4
  br label %_D3std5stdio4File__T6readlnTAyaZQmMFwZQk.exit

_D3std5stdio4File__T6readlnTAyaZQmMFwZQk.exit:    ; preds = %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit.i.i, %if1.i.i, %else.i.i, %if3.i.i
  %.fca.0.gep.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %buf.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.fca.1.gep.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %buf.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %16 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %3, align 8 ; [#uses = 2]
  %17 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %16, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %18 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %17, align 8 ; [#uses = 1]
  %19 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %16, i64 0, i32 4 ; [#uses = 1, type = i32*]
  %20 = load i32, i32* %19, align 4               ; [#uses = 1]
  %21 = call i64 @_D3std5stdio10readlnImplFPOS4core4stdcQBg8_IO_FILEKAawEQCbQCa4File11OrientationZm(i32 %20, i32 %terminator_arg, { i64, i8* }* nonnull dereferenceable(16) %buf.i, %core.stdc.stdio._IO_FILE* %18) #4 ; [#uses = 0]
  %.len.i = load i64, i64* %.fca.0.gep.i, align 8 ; [#uses = 1]
  %.ptr.i = load i8*, i8** %.fca.1.gep.i, align 8 ; [#uses = 1]
  %22 = insertvalue { i64, i8* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %23 = insertvalue { i64, i8* } %22, i8* %.ptr.i, 1 ; [#uses = 1]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2)
  ret { i64, i8* } %23
}

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

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

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

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

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

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

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

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

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

else.i:                                           ; preds = %if.i
  %.not7.i = icmp eq i32 %9, 0                    ; [#uses = 1]
  br i1 %.not7.i, label %_D3std5stdio4File__T6readlnTaZQkMFKAawZm.exit, label %if3.i

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

_D3std5stdio4File__T6readlnTaZQkMFKAawZm.exit:    ; preds = %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit.i, %if1.i, %else.i, %if3.i
  %.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**]
  %15 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %1, align 8 ; [#uses = 2]
  %16 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %15, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %17 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %16, align 8 ; [#uses = 1]
  %18 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %15, i64 0, i32 4 ; [#uses = 1, type = i32*]
  %19 = load i32, i32* %18, align 4               ; [#uses = 1]
  %20 = call i64 @_D3std5stdio10readlnImplFPOS4core4stdcQBg8_IO_FILEKAawEQCbQCa4File11OrientationZm(i32 %19, i32 %terminator_arg, { i64, i8* }* nonnull dereferenceable(16) %buf, %core.stdc.stdio._IO_FILE* %17) #4 ; [#uses = 0]
  %.len = load i64, i64* %.fca.0.gep, align 8     ; [#uses = 1]
  %.ptr = load i8*, i8** %.fca.1.gep, align 8     ; [#uses = 1]
  %21 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %22 = insertvalue { i64, i8* } %21, i8* %.ptr, 1 ; [#uses = 1]
  ret { i64, i8* } %22
}

; [#uses = 0]
; 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 #2 {
  %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.9, i32 0, i32 0) }, i64 2083, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.10, i32 0, i32 0) }) #13
  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) #4 ; [#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) #4 ; [#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 #2 {
  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) #13
  unreachable

endif:                                            ; preds = %0
  ret i1 true
}

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

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

; [#uses = 6]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #6 {
  %.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 = 2]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D9Exception7__ClassZ) #1 ; [#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
  %a_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %msg_arg, 0 ; [#uses = 2]
  %4 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract.i.i) #4 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %4, 1     ; [#uses = 2]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i.i, i8* nonnull align 1 %msg_arg.fca.1.extract, i64 %a_arg.fca.0.extract.i.i, i1 false) #4
  %.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.11, i64 0, i64 0), %condfalse ], [ %.ptr.i.i, %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) #4 ; [#uses = 0]
  %9 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %9) #3
  unreachable
}

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4idupTxaZQjFNaNbNdNfAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #2 {
  %a_arg.fca.0.extract.i = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 2]
  %a_arg.fca.1.extract.i = 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.i) #4 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %1, 1       ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i, i8* align 1 %a_arg.fca.1.extract.i, i64 %a_arg.fca.0.extract.i, i1 false) #4
  ret { i64, i8* } %1
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #2 {
  %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) #4 ; [#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) #4
  ret { i64, i8* } %1
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T8_dupCtfeTxaTyaZQqFNaNbNfMAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #2 {
  %res = alloca { i64, i8* }, align 8             ; [#uses = 4, size/byte = 16]
  %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]
  %.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**]
  %.not = icmp eq i64 %a_arg.fca.0.extract, 0     ; [#uses = 1]
  %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 i1 %.not, label %endfor, label %forbody

forbody:                                          ; preds = %0, %forbody
  %__key204.015 = phi i64 [ %4, %forbody ], [ 0, %0 ] ; [#uses = 2, type = i64]
  %2 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %__key204.015 ; [#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) #1 ; [#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 nuw i64 %__key204.015, 1               ; [#uses = 2]
  %exitcond.not = icmp eq i64 %4, %a_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %endfor.loopexit, label %forbody

endfor.loopexit:                                  ; preds = %forbody
  %.fca.0.load.pre = load i64, i64* %.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.1.load.pre = load i8*, i8** %.fca.1.gep, align 8 ; [#uses = 1]
  br label %endfor

endfor:                                           ; preds = %endfor.loopexit, %0
  %.fca.1.load = phi i8* [ %.fca.1.load.pre, %endfor.loopexit ], [ null, %0 ] ; [#uses = 1, type = i8*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %endfor.loopexit ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#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 = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAyaZQlFNaNbNdNiNfMKQtZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #2 {
  %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 = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5range10primitives__T4saveTaZQiFNaNbNdNiNfMNkANgaZQf({ i64, i8* } %a_arg) local_unnamed_addr #2 {
  ret { i64, i8* } %a_arg
}

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__TQjTSQr9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCu8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6ResultZQGcFNaNbNfQGaZAQEv(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* byval align 8 %r) local_unnamed_addr #2 {
  %arr.i.i.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 2, size/byte = 16]
  %arr.i.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 3, size/byte = 16]
  %a = alloca %"std.array.Appender!(string[]).Appender", align 8 ; [#uses = 4, size/byte = 8]
  %1 = bitcast { i64, { i64, i8* }* }* %arr.i.i to i8* ; [#uses = 3]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %1)
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %1, i8 0, i64 16, i1 false)
  %.gc_struct.i.i = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ to %object.TypeInfo*)) #1 ; [#uses = 4]
  %2 = bitcast { i64, { i64, i8* }* }* %arr.i.i.i to i8* ; [#uses = 3]
  tail call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %.gc_struct.i.i, i8 0, i64 32, i1 false)
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %2)
  %3 = bitcast { i64, { i64, i8* }* }* %arr.i.i.i to { i64, i8* }* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %2, i8 0, i64 16, i1 false)
  %4 = call i64 @_d_arraysetcapacity(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), i64 0, { i64, i8* }* nonnull %3) #4 ; [#uses = 2]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2)
  %.not.i = icmp eq i64 %4, 0                     ; [#uses = 1]
  br i1 %.not.i, label %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit, label %if.i.i

if.i.i:                                           ; preds = %0
  %arr_arg.fca.0.gep.i.i = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr.i.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %5 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %4, { i64, { i64, i8* }* }* nonnull dereferenceable(16) %arr.i.i) #14 ; [#uses = 0]
  %.len3.pre.i.i = load i64, i64* %arr_arg.fca.0.gep.i.i, align 8 ; [#uses = 1]
  br label %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit

_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit: ; preds = %0, %if.i.i
  %.len3.i.i = phi i64 [ %.len3.pre.i.i, %if.i.i ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %6 = bitcast i8* %.gc_struct.i.i to i64*        ; [#uses = 1]
  store i64 %.len3.i.i, i64* %6, align 8
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %1)
  %.sroa.0.0..sroa_idx = getelementptr inbounds %"std.array.Appender!(string[]).Appender", %"std.array.Appender!(string[]).Appender"* %a, i64 0, i32 0 ; [#uses = 5, type = %"std.array.Appender!(string[]).Appender.Data"**]
  %7 = bitcast %"std.array.Appender!(string[]).Appender"* %a to i8** ; [#uses = 1]
  store i8* %.gc_struct.i.i, i8** %7, align 8
  %__r233.sroa.0.0..sroa_idx = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %r, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %__r233.sroa.0.0.copyload = load i64, i64* %__r233.sroa.0.0..sroa_idx, align 8 ; [#uses = 2]
  %__r233.sroa.9.0..sroa_idx22 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %r, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %__r233.sroa.9.0.copyload = load i8*, i8** %__r233.sroa.9.0..sroa_idx22, align 8 ; [#uses = 2]
  %__r233.sroa.18.0..sroa_idx23 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %r, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %__r233.sroa.18.0.copyload = load i64, i64* %__r233.sroa.18.0..sroa_idx23, align 8 ; [#uses = 3]
  %__r233.sroa.21.0..sroa_idx24 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %r, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %__r233.sroa.21.0.copyload = load i8*, i8** %__r233.sroa.21.0..sroa_idx24, align 8 ; [#uses = 1]
  %__r233.sroa.23.0..sroa_idx25 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %r, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %__r233.sroa.23.0.copyload = load i64, i64* %__r233.sroa.23.0..sroa_idx25, align 8 ; [#uses = 2]
  %.not.i8.i.i = icmp eq i64 %__r233.sroa.18.0.copyload, 0 ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %__r233.sroa.18.0.copyload, 0 ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %__r233.sroa.21.0.copyload, 1 ; [#uses = 2]
  br i1 %.not.i8.i.i, label %forcond.us.preheader, label %forcond

forcond.us.preheader:                             ; preds = %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit
  %10 = bitcast i8* %.gc_struct.i.i to %"std.array.Appender!(string[]).Appender.Data"* ; [#uses = 1]
  br label %forcond.us

forcond.us:                                       ; preds = %forcond.us.preheader, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us
  %11 = phi %"std.array.Appender!(string[]).Appender.Data"* [ %21, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us ], [ %10, %forcond.us.preheader ] ; [#uses = 1, type = %"std.array.Appender!(string[]).Appender.Data"*]
  %__r233.sroa.23.0.us = phi i64 [ -1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us ], [ %__r233.sroa.23.0.copyload, %forcond.us.preheader ] ; [#uses = 2, type = i64]
  %__r233.sroa.9.0.us = phi i8* [ %__r233.sroa.9.1.us, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us ], [ %__r233.sroa.9.0.copyload, %forcond.us.preheader ] ; [#uses = 2, type = i8*]
  %__r233.sroa.0.0.us = phi i64 [ %24, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us ], [ %__r233.sroa.0.0.copyload, %forcond.us.preheader ] ; [#uses = 4, type = i64]
  %12 = icmp eq i64 %__r233.sroa.23.0.us, -1      ; [#uses = 1]
  br i1 %12, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us: ; preds = %forcond.us
  %.not.i.i.us = icmp eq i64 %__r233.sroa.0.0.us, 0 ; [#uses = 1]
  br i1 %.not.i.i.us, label %endfor, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us: ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us, %forcond.us
  %__r233.sroa.23.1.us = phi i64 [ %__r233.sroa.23.0.us, %forcond.us ], [ 1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us ] ; [#uses = 5, type = i64]
  %bounds.cmp.up.not.i.us = icmp ult i64 %__r233.sroa.0.0.us, %__r233.sroa.23.1.us ; [#uses = 1]
  br i1 %bounds.cmp.up.not.i.us, label %bounds.fail.i, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit.us

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit.us: ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us
  call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %a, i64 1) #2
  %13 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 2]
  %14 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %13, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i1.us = load i64, i64* %14, align 8       ; [#uses = 4]
  %15 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %13, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.ptr.i.i.us = load { i64, i8* }*, { i64, i8* }** %15, align 8 ; [#uses = 3]
  %bounds.cmp.not.i.us = icmp eq i64 %.len.i1.us, -1 ; [#uses = 1]
  br i1 %bounds.cmp.not.i.us, label %bounds.fail.i2, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18.us: ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit.us
  %16 = add i64 %.len.i1.us, 1                    ; [#uses = 1]
  %17 = ptrtoint i8* %__r233.sroa.9.0.us to i64   ; [#uses = 1]
  %18 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i.i.us, i64 %.len.i1.us, i32 1 ; [#uses = 1, type = i8**]
  %19 = bitcast i8** %18 to i64*                  ; [#uses = 1]
  %20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i.i.us, i64 %.len.i1.us, i32 0 ; [#uses = 1, type = i64*]
  store i64 %__r233.sroa.23.1.us, i64* %20, align 8
  store i64 %17, i64* %19, align 8
  %21 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 3]
  %22 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %21, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %16, i64* %22, align 8
  %23 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %21, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  store { i64, i8* }* %.ptr.i.i.us, { i64, i8* }** %23, align 8
  %24 = sub i64 %__r233.sroa.0.0.us, %__r233.sroa.23.1.us ; [#uses = 1]
  %__r233.sroa.9.1.us = getelementptr inbounds i8, i8* %__r233.sroa.9.0.us, i64 %__r233.sroa.23.1.us ; [#uses = 1, type = i8*]
  br label %forcond.us

forcond:                                          ; preds = %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit
  %__r233.sroa.23.0 = phi i64 [ %__r233.sroa.23.2, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit ], [ %__r233.sroa.23.0.copyload, %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit ] ; [#uses = 2, type = i64]
  %__r233.sroa.9.0 = phi i8* [ %__r233.sroa.9.1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit ], [ %__r233.sroa.9.0.copyload, %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit ] ; [#uses = 4, type = i8*]
  %__r233.sroa.0.0 = phi i64 [ %__r233.sroa.0.1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit ], [ %__r233.sroa.0.0.copyload, %_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo.exit ] ; [#uses = 16, type = i64]
  %25 = icmp eq i64 %__r233.sroa.23.0, -1         ; [#uses = 1]
  br i1 %25, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit: ; preds = %forcond
  %.not.i.i = icmp eq i64 %__r233.sroa.0.0, 0     ; [#uses = 1]
  br i1 %.not.i.i, label %endfor.loopexit39, label %condfalse.i.i

condfalse.i.i:                                    ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  %26 = insertvalue { i64, i8* } undef, i64 %__r233.sroa.0.0, 0 ; [#uses = 1]
  %27 = insertvalue { i64, i8* } %26, i8* %__r233.sroa.9.0, 1 ; [#uses = 1]
  %28 = call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %9, { i64, i8* } %27) #4 ; [#uses = 1]
  %.len1.i.i = extractvalue { i64, i8* } %28, 0   ; [#uses = 1]
  %29 = sub i64 %__r233.sroa.0.0, %.len1.i.i      ; [#uses = 1]
  br label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i: ; preds = %condfalse.i.i, %forcond
  %__r233.sroa.23.1 = phi i64 [ %__r233.sroa.23.0, %forcond ], [ %29, %condfalse.i.i ] ; [#uses = 5, type = i64]
  %bounds.cmp.up.not.i = icmp ugt i64 %__r233.sroa.23.1, %__r233.sroa.0.0 ; [#uses = 1]
  br i1 %bounds.cmp.up.not.i, label %bounds.fail.i, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit

bounds.fail.i:                                    ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us
  %__r233.sroa.23.1.lcssa = phi i64 [ %__r233.sroa.23.1.us, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us ], [ %__r233.sroa.23.1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i ] ; [#uses = 1, type = i64]
  %__r233.sroa.0.0.lcssa29 = phi i64 [ %__r233.sroa.0.0.us, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i.us ], [ %__r233.sroa.0.0, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i ] ; [#uses = 1, type = i64]
  call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5825, i64 0, i64 %__r233.sroa.23.1.lcssa, i64 %__r233.sroa.0.0.lcssa29) #3
  unreachable

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit: ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i
  call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %a, i64 1) #2
  %30 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 2]
  %31 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %30, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i1 = load i64, i64* %31, align 8          ; [#uses = 4]
  %32 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %30, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %.ptr.i.i = load { i64, i8* }*, { i64, i8* }** %32, align 8 ; [#uses = 3]
  %bounds.cmp.not.i = icmp eq i64 %.len.i1, -1    ; [#uses = 1]
  br i1 %bounds.cmp.not.i, label %bounds.fail.i2, label %_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv.exit

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

_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv.exit: ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy.exit
  %33 = add i64 %.len.i1, 1                       ; [#uses = 1]
  %34 = ptrtoint i8* %__r233.sroa.9.0 to i64      ; [#uses = 1]
  %35 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i.i, i64 %.len.i1, i32 1 ; [#uses = 1, type = i8**]
  %36 = bitcast i8** %35 to i64*                  ; [#uses = 1]
  %37 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.ptr.i.i, i64 %.len.i1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %__r233.sroa.23.1, i64* %37, align 8
  store i64 %34, i64* %36, align 8
  %38 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 2]
  %39 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %38, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %33, i64* %39, align 8
  %40 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %38, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  store { i64, i8* }* %.ptr.i.i, { i64, i8* }** %40, align 8
  %41 = icmp eq i64 %__r233.sroa.23.1, -1         ; [#uses = 1]
  br i1 %41, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.i5, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.i5: ; preds = %_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv.exit
  %.not.i.i.i4 = icmp eq i64 %__r233.sroa.0.0, 0  ; [#uses = 1]
  br i1 %.not.i.i.i4, label %assertFailed.i20, label %condfalse.i.i14

condfalse.i.i14:                                  ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.i5
  %42 = insertvalue { i64, i8* } undef, i64 %__r233.sroa.0.0, 0 ; [#uses = 1]
  %43 = insertvalue { i64, i8* } %42, i8* %__r233.sroa.9.0, 1 ; [#uses = 1]
  %44 = call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %9, { i64, i8* } %43) #4 ; [#uses = 1]
  %.len1.i.i13 = extractvalue { i64, i8* } %44, 0 ; [#uses = 1]
  %45 = sub i64 %__r233.sroa.0.0, %.len1.i.i13    ; [#uses = 1]
  br label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18: ; preds = %condfalse.i.i14, %_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv.exit
  %46 = phi i64 [ %__r233.sroa.23.1, %_D3std5array__T8AppenderTAAyaZQp__T3putTQoZQiMFNaNbNfQBbZv.exit ], [ %45, %condfalse.i.i14 ] ; [#uses = 2, type = i64]
  %47 = icmp eq i64 %46, %__r233.sroa.0.0         ; [#uses = 1]
  br i1 %47, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit, label %endif.i

endif.i:                                          ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18
  %48 = add i64 %46, %__r233.sroa.18.0.copyload   ; [#uses = 5]
  %49 = icmp eq i64 %__r233.sroa.0.0, %48         ; [#uses = 1]
  br i1 %49, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit, label %endif4.i

endif4.i:                                         ; preds = %endif.i
  %bounds.cmp.lo20.not.i = icmp ult i64 %__r233.sroa.0.0, %48 ; [#uses = 1]
  br i1 %bounds.cmp.lo20.not.i, label %bounds.fail17.i, label %bounds.ok16.i

bounds.ok16.i:                                    ; preds = %endif4.i
  %50 = sub i64 %__r233.sroa.0.0, %48             ; [#uses = 1]
  br label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit

bounds.fail17.i:                                  ; preds = %endif4.i
  call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5875, i64 %48, i64 %__r233.sroa.0.0, i64 %__r233.sroa.0.0) #3
  unreachable

assertFailed.i20:                                 ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.i5
  call void @_d_assert_msg({ i64, i8* } { i64 41, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.16, i32 0, i32 0) }, { i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5849) #3
  unreachable

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv.exit: ; preds = %endif.i, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18, %bounds.ok16.i
  %__r233.sroa.23.2 = phi i64 [ -1, %bounds.ok16.i ], [ -1, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18 ], [ 0, %endif.i ] ; [#uses = 1, type = i64]
  %__r233.sroa.0.0.pn = phi i64 [ %48, %bounds.ok16.i ], [ %__r233.sroa.0.0, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18 ], [ %__r233.sroa.0.0, %endif.i ] ; [#uses = 1, type = i64]
  %__r233.sroa.0.1 = phi i64 [ %50, %bounds.ok16.i ], [ 0, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit.i18 ], [ 0, %endif.i ] ; [#uses = 1, type = i64]
  %__r233.sroa.9.1 = getelementptr inbounds i8, i8* %__r233.sroa.9.0, i64 %__r233.sroa.0.0.pn ; [#uses = 1, type = i8*]
  br label %forcond

endfor.loopexit39:                                ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  %.pre = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %.sroa.0.0..sroa_idx, align 8 ; [#uses = 1]
  br label %endfor

endfor:                                           ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us, %endfor.loopexit39
  %51 = phi %"std.array.Appender!(string[]).Appender.Data"* [ %.pre, %endfor.loopexit39 ], [ %11, %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit.us ] ; [#uses = 3, type = %"std.array.Appender!(string[]).Appender.Data"*]
  %.not.i.i21 = icmp eq %"std.array.Appender!(string[]).Appender.Data"* %51, null ; [#uses = 1]
  br i1 %.not.i.i21, label %_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya.exit, label %condtrue.i.i

condtrue.i.i:                                     ; preds = %endfor
  %.fca.0.gep2.phi.trans.insert.i.i = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %51, 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"* %51, 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 = %endfor, %condtrue.i.i
  %.fca.1.load.i.i = phi { i64, i8* }* [ %.fca.1.load.pre.i.i, %condtrue.i.i ], [ null, %endfor ] ; [#uses = 1, type = { i64, i8* }*]
  %.fca.0.load.i.i = phi i64 [ %.fca.0.load.pre.i.i, %condtrue.i.i ], [ 0, %endfor ] ; [#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 = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFNaNbNiNfQDzQEcZSQFsQFrQFk__TQFdVQExa6_61203d3d2062VQExi0TQFwTQGaZQGoFQGiQGlZ6Result(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* noalias sret align 8 %.sret_arg, { i64, i8* } %s_arg, { i64, i8* } %r_arg) local_unnamed_addr #2 {
  %.repack = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.repack3 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.repack4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.repack5 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg, i64 0, i32 2 ; [#uses = 1, type = i64*]
  store i64 -1, i64* %1, align 8
  %input_arg.fca.0.extract.i = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %separator_arg.fca.0.extract.i = extractvalue { i64, i8* } %s_arg, 0 ; [#uses = 1]
  %separator_arg.fca.1.extract.i = extractvalue { i64, i8* } %s_arg, 1 ; [#uses = 1]
  store i64 %input_arg.fca.0.extract.i, i64* %.repack, align 8
  store i8* %input_arg.fca.1.extract.i, i8** %.repack3, align 8
  store i64 %separator_arg.fca.0.extract.i, i64* %.repack4, align 8
  store i8* %separator_arg.fca.1.extract.i, i8** %.repack5, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result15separatorLengthMFNaNbNdNiNfZm(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  ret i64 %.len
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 2 ; [#uses = 2, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %.not = icmp eq i64 %2, -1                      ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  ret void

endif:                                            ; preds = %0
  %3 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %3, align 8            ; [#uses = 3]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br i1 %.not.i, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %endif
  %4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i7 = load i64, i64* %4, align 8           ; [#uses = 2]
  %.not.i8 = icmp eq i64 %.len.i7, 0              ; [#uses = 1]
  br i1 %.not.i8, label %condend, label %condfalse

condfalse:                                        ; preds = %assertPassed
  %5 = insertvalue { i64, i8* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %.elt3 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack4 = load i8*, i8** %.elt3, align 8      ; [#uses = 1]
  %6 = insertvalue { i64, i8* } %5, i8* %.unpack4, 1 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } undef, i64 %.len.i7, 0 ; [#uses = 1]
  %.elt5 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6 = load i8*, i8** %.elt5, align 8      ; [#uses = 1]
  %8 = insertvalue { i64, i8* } %7, i8* %.unpack6, 1 ; [#uses = 1]
  %9 = tail call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %8, { i64, i8* } %6) #4 ; [#uses = 1]
  %.len1 = extractvalue { i64, i8* } %9, 0        ; [#uses = 1]
  %10 = sub i64 %.len.i, %.len1                   ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %assertPassed, %condfalse
  %condtmp.0.sroa.speculated = phi i64 [ %10, %condfalse ], [ 1, %assertPassed ] ; [#uses = 1, type = i64]
  store i64 %condtmp.0.sroa.speculated, i64* %1, align 8
  ret void

assertFailed:                                     ; preds = %endif
  tail call void @_d_assert_msg({ i64, i8* } { i64 27, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.13, i32 0, i32 0) }, { i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5807) #3
  unreachable
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TQtTQwZQBfFNaNbNiNfQBlMQBpZQBt({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #2 {
  %1 = tail call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) #4 ; [#uses = 1]
  ret { i64, i8* } %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result6__ctorMFNaNbNcNiNfQEyQFbZSQGrQGqQGj__TQGcVQFwa6_61203d3d2062VQFwi0TQGvTQGzZQHnFQHhQHkZQDq(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull returned %.this_arg, { i64, i8* } %separator_arg, { i64, i8* } %input_arg) local_unnamed_addr #2 {
  %input_arg.fca.0.extract = extractvalue { i64, i8* } %input_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract = extractvalue { i64, i8* } %input_arg, 1 ; [#uses = 1]
  %separator_arg.fca.0.extract = extractvalue { i64, i8* } %separator_arg, 0 ; [#uses = 1]
  %separator_arg.fca.1.extract = extractvalue { i64, i8* } %separator_arg, 1 ; [#uses = 1]
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %input_arg.fca.0.extract, i64* %1, align 8
  %2 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %input_arg.fca.1.extract, i8** %2, align 8
  %3 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %separator_arg.fca.0.extract, i64* %3, align 8
  %4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  store i8* %separator_arg.fca.1.extract, i8** %4, align 8
  ret %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5frontMFNaNbNdNiNfZQEy(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 2 ; [#uses = 2, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 2]
  %3 = icmp eq i64 %2, -1                         ; [#uses = 1]
  br i1 %3, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit: ; preds = %0
  %4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i = load i64, i64* %4, align 8          ; [#uses = 3]
  %.not.i.i = icmp eq i64 %.len.i.i, 0            ; [#uses = 1]
  br i1 %.not.i.i, label %assertFailed, label %assertPassed.i

assertPassed.i:                                   ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  %5 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i7.i = load i64, i64* %5, align 8         ; [#uses = 2]
  %.not.i8.i = icmp eq i64 %.len.i7.i, 0          ; [#uses = 1]
  br i1 %.not.i8.i, label %condend.i, label %condfalse.i

condfalse.i:                                      ; preds = %assertPassed.i
  %6 = insertvalue { i64, i8* } undef, i64 %.len.i.i, 0 ; [#uses = 1]
  %.elt3.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack4.i = load i8*, i8** %.elt3.i, align 8  ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack4.i, 1 ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.len.i7.i, 0 ; [#uses = 1]
  %.elt5.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6.i = load i8*, i8** %.elt5.i, align 8  ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack6.i, 1 ; [#uses = 1]
  %10 = tail call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %9, { i64, i8* } %7) #4 ; [#uses = 1]
  %.len1.i = extractvalue { i64, i8* } %10, 0     ; [#uses = 1]
  %11 = sub i64 %.len.i.i, %.len1.i               ; [#uses = 1]
  br label %condend.i

condend.i:                                        ; preds = %condfalse.i, %assertPassed.i
  %condtmp.0.sroa.speculated.i = phi i64 [ %11, %condfalse.i ], [ 1, %assertPassed.i ] ; [#uses = 2, type = i64]
  store i64 %condtmp.0.sroa.speculated.i, i64* %1, align 8
  br label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit: ; preds = %0, %condend.i
  %12 = phi i64 [ %2, %0 ], [ %condtmp.0.sroa.speculated.i, %condend.i ] ; [#uses = 3, type = i64]
  %13 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %13, align 8             ; [#uses = 2]
  %bounds.cmp.up.not = icmp ugt i64 %12, %.len    ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit
  %14 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %14, align 8             ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %12, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %.ptr, 1 ; [#uses = 1]
  ret { i64, i8* } %16

bounds.fail:                                      ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5825, i64 0, i64 %12, i64 %.len) #3
  unreachable

assertFailed:                                     ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  tail call void @_d_assert_msg({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5823) #3
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = icmp eq i64 %2, -1                         ; [#uses = 1]
  br i1 %3, label %andand, label %andandend

andand:                                           ; preds = %0
  %4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %4, align 8            ; [#uses = 1]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br label %andandend

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result8popFrontMFNaNbNiNfZv(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 2 ; [#uses = 5, type = i64*]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 2]
  %3 = icmp eq i64 %2, -1                         ; [#uses = 1]
  br i1 %3, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit, label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit: ; preds = %0
  %4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i = load i64, i64* %4, align 8          ; [#uses = 3]
  %.not.i.i = icmp eq i64 %.len.i.i, 0            ; [#uses = 1]
  br i1 %.not.i.i, label %assertFailed, label %assertPassed.i

assertPassed.i:                                   ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  %5 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i7.i = load i64, i64* %5, align 8         ; [#uses = 2]
  %.not.i8.i = icmp eq i64 %.len.i7.i, 0          ; [#uses = 1]
  br i1 %.not.i8.i, label %condend.i, label %condfalse.i

condfalse.i:                                      ; preds = %assertPassed.i
  %6 = insertvalue { i64, i8* } undef, i64 %.len.i.i, 0 ; [#uses = 1]
  %.elt3.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack4.i = load i8*, i8** %.elt3.i, align 8  ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack4.i, 1 ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.len.i7.i, 0 ; [#uses = 1]
  %.elt5.i = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6.i = load i8*, i8** %.elt5.i, align 8  ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack6.i, 1 ; [#uses = 1]
  %10 = tail call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %9, { i64, i8* } %7) #4 ; [#uses = 1]
  %.len1.i = extractvalue { i64, i8* } %10, 0     ; [#uses = 1]
  %11 = sub i64 %.len.i.i, %.len1.i               ; [#uses = 1]
  br label %condend.i

condend.i:                                        ; preds = %condfalse.i, %assertPassed.i
  %condtmp.0.sroa.speculated.i = phi i64 [ %11, %condfalse.i ], [ 1, %assertPassed.i ] ; [#uses = 2, type = i64]
  store i64 %condtmp.0.sroa.speculated.i, i64* %1, align 8
  br label %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit

_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit: ; preds = %0, %condend.i
  %12 = phi i64 [ %2, %0 ], [ %condtmp.0.sroa.speculated.i, %condend.i ] ; [#uses = 3, type = i64]
  %13 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 4, type = i64*]
  %.len = load i64, i64* %13, align 8             ; [#uses = 7]
  %14 = icmp eq i64 %12, %.len                    ; [#uses = 1]
  br i1 %14, label %bounds.ok, label %endif

bounds.ok:                                        ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit
  %15 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 2, type = i8**]
  %.ptr = load i8*, i8** %15, align 8             ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %12 ; [#uses = 1, type = i8*]
  store i64 0, i64* %13, align 8
  store i8* %lowerbound, i8** %15, align 8
  store i64 -1, i64* %1, align 8
  ret void

endif:                                            ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result17ensureFrontLengthMFNaNbNiNfZv.exit
  %16 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len.i24 = load i64, i64* %16, align 8         ; [#uses = 1]
  %17 = add i64 %.len.i24, %12                    ; [#uses = 5]
  %18 = icmp eq i64 %.len, %17                    ; [#uses = 1]
  br i1 %18, label %bounds.ok7, label %endif4

bounds.ok7:                                       ; preds = %endif
  %19 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 2, type = i8**]
  %.ptr12 = load i8*, i8** %19, align 8           ; [#uses = 1]
  %lowerbound13 = getelementptr inbounds i8, i8* %.ptr12, i64 %.len ; [#uses = 1, type = i8*]
  store i64 0, i64* %13, align 8
  store i8* %lowerbound13, i8** %19, align 8
  store i64 0, i64* %1, align 8
  ret void

endif4:                                           ; preds = %endif
  %bounds.cmp.lo20.not = icmp ult i64 %.len, %17  ; [#uses = 1]
  br i1 %bounds.cmp.lo20.not, label %bounds.fail17, label %bounds.ok16

bounds.ok16:                                      ; preds = %endif4
  %20 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 2, type = i8**]
  %.ptr21 = load i8*, i8** %20, align 8           ; [#uses = 1]
  %lowerbound22 = getelementptr inbounds i8, i8* %.ptr21, i64 %17 ; [#uses = 1, type = i8*]
  %21 = sub i64 %.len, %17                        ; [#uses = 1]
  store i64 %21, i64* %13, align 8
  store i8* %lowerbound22, i8** %20, align 8
  store i64 -1, i64* %1, align 8
  ret void

bounds.fail17:                                    ; preds = %endif4
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5875, i64 %17, i64 %.len, i64 %.len) #3
  unreachable

assertFailed:                                     ; preds = %_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result5emptyMFNaNbNdNiNfZb.exit
  tail call void @_d_assert_msg({ i64, i8* } { i64 41, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.16, i32 0, i32 0) }, { i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i32 0, i32 0) }, i32 5849) #3
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result4saveMFNaNbNdNiNfZSQGjQGiQGb__TQFuVQFoa6_61203d3d2062VQFoi0TQGnTQGrZQHfFQGzQHcZQDi(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* noalias sret align 8 %.sret_arg, %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* nonnull %.this_arg) local_unnamed_addr #2 {
  %1 = bitcast %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg to i8* ; [#uses = 1]
  %2 = bitcast %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg to i8* ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(40) %1, i8* nonnull align 1 dereferenceable(40) %2, i64 40, i1 false)
  %3 = bitcast %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.this_arg to <2 x i64>* ; [#uses = 1]
  %4 = load <2 x i64>, <2 x i64>* %3, align 8     ; [#uses = 1]
  %5 = bitcast %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %.sret_arg to <2 x i64>* ; [#uses = 1]
  store <2 x i64> %4, <2 x i64>* %5, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result11__xopEqualsFKxSQGhQGgQFz__TQFsVQFma6_61203d3d2062VQFmi0TQGlTQGpZQHdFQGxQHaZQDgKxQCoZb(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* dereferenceable(40) %q, %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* dereferenceable(40) %p) local_unnamed_addr #2 {
  %.elt = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %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]
  %.elt4 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack5 = load i8*, i8** %.elt4, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack5, 1 ; [#uses = 1]
  %.elt6 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %q, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack7 = load i64, i64* %.elt6, align 8      ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack7, 0 ; [#uses = 1]
  %.elt8 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %q, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack9 = load i8*, i8** %.elt8, align 8      ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack9, 1 ; [#uses = 1]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #4 ; [#uses = 1]
  br i1 %5, label %andand, label %andandend2

andand:                                           ; preds = %0
  %.elt10 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack11 = load i64, i64* %.elt10, align 8    ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack11, 0 ; [#uses = 1]
  %.elt12 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack13 = load i8*, i8** %.elt12, align 8    ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack13, 1 ; [#uses = 1]
  %.elt14 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %q, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack15 = load i64, i64* %.elt14, align 8    ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.unpack15, 0 ; [#uses = 1]
  %.elt16 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %q, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack17 = load i8*, i8** %.elt16, align 8    ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack17, 1 ; [#uses = 1]
  %10 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %9, { i64, i8* } %7) #4 ; [#uses = 1]
  br i1 %10, label %andand1, label %andandend2

andand1:                                          ; preds = %andand
  %11 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %12 = getelementptr inbounds %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %q, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %13 = load i64, i64* %11, align 8               ; [#uses = 1]
  %14 = load i64, i64* %12, align 8               ; [#uses = 1]
  %15 = icmp eq i64 %13, %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 = 5]
declare zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* }, { i64, i8* }) local_unnamed_addr #4

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFQDrQDuZ6Result9__xtoHashFNbNeKxSQGiQGhQGa__TQFtVQFna6_61203d3d2062VQFni0TQGmTQGqZQHeFQGyQHbZQDhZm(%"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* dereferenceable(40) %p) local_unnamed_addr #2 {
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 %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D13TypeInfo_xAya6__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* @_D13TypeInfo_xAya6__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.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %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 @_D13TypeInfo_xAya6__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_xm6__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.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result", %"std.algorithm.iteration.splitter!(\22a == b\22, Flag.no, string, string).splitter.Result"* %p, i64 0, i32 2 ; [#uses = 1, type = i64*]
  %18 = bitcast i64* %17 to i8*                   ; [#uses = 1]
  %19 = tail call i64 %16(%object.TypeInfo_Const* nonnull @_D11TypeInfo_xm6__initZ, i8* nonnull %18) ; [#uses = 1]
  %20 = add i64 %19, %13                          ; [#uses = 1]
  ret i64 %20
}

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

; [#uses = 6]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #2 {
  %haystack_arg.fca.0.extract = extractvalue { i64, i8* } %haystack_arg, 0 ; [#uses = 14]
  %haystack_arg.fca.1.extract = extractvalue { i64, i8* } %haystack_arg, 1 ; [#uses = 6]
  %needle_arg.fca.0.extract = extractvalue { i64, i8* } %needle_arg, 0 ; [#uses = 10]
  %needle_arg.fca.1.extract = extractvalue { i64, i8* } %needle_arg, 1 ; [#uses = 3]
  %.not.i = icmp eq i64 %needle_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not.i, label %if, label %endif

if:                                               ; preds = %0
  ret { i64, i8* } %haystack_arg

endif:                                            ; preds = %0
  %1 = icmp ugt i64 %needle_arg.fca.0.extract, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %1, label %bounds.ok, label %bounds.ok9

bounds.ok:                                        ; preds = %endif
  %lowerbound = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %haystack_arg.fca.0.extract ; [#uses = 1, type = i8*]
  %2 = insertvalue { i64, i8* } { i64 0, i8* undef }, i8* %lowerbound, 1 ; [#uses = 1]
  ret { i64, i8* } %2

bounds.ok9:                                       ; preds = %endif
  %3 = add i64 %needle_arg.fca.0.extract, -1      ; [#uses = 7]
  %4 = getelementptr inbounds i8, i8* %needle_arg.fca.1.extract, i64 %3 ; [#uses = 1, type = i8*]
  %5 = load i8, i8* %4, align 1                   ; [#uses = 3]
  %6 = icmp ult i64 %3, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %6, label %bounds.ok15.lr.ph, label %bounds.ok65

bounds.ok15.lr.ph:                                ; preds = %bounds.ok9
  %7 = icmp eq i64 %3, 0                          ; [#uses = 1]
  br i1 %7, label %bounds.ok15.us, label %bounds.ok15.us138

bounds.ok15.us:                                   ; preds = %bounds.ok15.lr.ph, %if18.us
  %j.0137.us = phi i64 [ %11, %if18.us ], [ 0, %bounds.ok15.lr.ph ] ; [#uses = 3, type = i64]
  %8 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %j.0137.us ; [#uses = 1, type = i8*]
  %9 = load i8, i8* %8, align 1                   ; [#uses = 1]
  %10 = icmp eq i8 %9, %5                         ; [#uses = 1]
  br i1 %10, label %if24, label %if18.us

if18.us:                                          ; preds = %bounds.ok15.us
  %11 = add i64 %j.0137.us, 1                     ; [#uses = 2]
  %exitcond.not = icmp eq i64 %11, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.ok65, label %bounds.ok15.us

bounds.ok15.us138:                                ; preds = %bounds.ok15.lr.ph, %forinc.us158
  %j.0137.us139 = phi i64 [ %j.1.us160, %forinc.us158 ], [ %3, %bounds.ok15.lr.ph ] ; [#uses = 4, type = i64]
  %skip.0136.us140 = phi i64 [ %skip.3.us159, %forinc.us158 ], [ 0, %bounds.ok15.lr.ph ] ; [#uses = 3, type = i64]
  %12 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %j.0137.us139 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %14 = icmp eq i8 %13, %5                        ; [#uses = 1]
  br i1 %14, label %endif19.us142, label %if18.us141

if18.us141:                                       ; preds = %bounds.ok15.us138
  %15 = add nuw i64 %j.0137.us139, 1              ; [#uses = 1]
  br label %forinc.us158

endif19.us142:                                    ; preds = %bounds.ok15.us138
  %16 = sub i64 %j.0137.us139, %3                 ; [#uses = 4]
  br label %endif25.us143

endif25.us143:                                    ; preds = %endif19.us142, %forinc22.us161
  %i.0131.us144 = phi i64 [ 0, %endif19.us142 ], [ %30, %forinc22.us161 ] ; [#uses = 4, type = i64]
  %17 = add nuw i64 %i.0131.us144, %16            ; [#uses = 2]
  %bounds.cmp36.us145 = icmp ult i64 %17, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp36.us145, label %bounds.ok37.us146, label %bounds.fail38.loopexit

bounds.ok37.us146:                                ; preds = %endif25.us143
  %exitcond199.not = icmp eq i64 %i.0131.us144, %needle_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond199.not, label %bounds.fail43, label %bounds.ok42.us148

bounds.ok42.us148:                                ; preds = %bounds.ok37.us146
  %18 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %17 ; [#uses = 1, type = i8*]
  %19 = getelementptr inbounds i8, i8* %needle_arg.fca.1.extract, i64 %i.0131.us144 ; [#uses = 1, type = i8*]
  %20 = load i8, i8* %18, align 1                 ; [#uses = 1]
  %21 = load i8, i8* %19, align 1                 ; [#uses = 1]
  %22 = icmp eq i8 %20, %21                       ; [#uses = 1]
  br i1 %22, label %forinc22.us161, label %endfor23.us149

endfor23.us149:                                   ; preds = %bounds.ok42.us148
  %23 = icmp eq i64 %skip.0136.us140, 0           ; [#uses = 1]
  br i1 %23, label %andand.us150, label %endif48.us156

andand.us150:                                     ; preds = %endfor23.us149, %forbody50.us155
  %skip.1133.us151 = phi i64 [ %27, %forbody50.us155 ], [ 1, %endfor23.us149 ] ; [#uses = 3, type = i64]
  %24 = sub i64 %3, %skip.1133.us151              ; [#uses = 3]
  %bounds.cmp54.us152 = icmp ult i64 %24, %needle_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp54.us152, label %bounds.ok60.us153, label %bounds.fail56

bounds.ok60.us153:                                ; preds = %andand.us150
  %25 = getelementptr inbounds i8, i8* %needle_arg.fca.1.extract, i64 %24 ; [#uses = 1, type = i8*]
  %26 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %.not.us154 = icmp eq i8 %26, %5                ; [#uses = 1]
  br i1 %.not.us154, label %endif48.us156, label %forbody50.us155

forbody50.us155:                                  ; preds = %bounds.ok60.us153
  %27 = add nuw i64 %skip.1133.us151, 1           ; [#uses = 2]
  %exitcond200.not = icmp eq i64 %27, %needle_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond200.not, label %endif48.us156, label %andand.us150

endif48.us156:                                    ; preds = %bounds.ok60.us153, %forbody50.us155, %endfor23.us149
  %skip.2.us157 = phi i64 [ %skip.0136.us140, %endfor23.us149 ], [ %needle_arg.fca.0.extract, %forbody50.us155 ], [ %skip.1133.us151, %bounds.ok60.us153 ] ; [#uses = 2, type = i64]
  %28 = add i64 %skip.2.us157, %j.0137.us139      ; [#uses = 1]
  br label %forinc.us158

forinc.us158:                                     ; preds = %endif48.us156, %if18.us141
  %skip.3.us159 = phi i64 [ %skip.0136.us140, %if18.us141 ], [ %skip.2.us157, %endif48.us156 ] ; [#uses = 1, type = i64]
  %j.1.us160 = phi i64 [ %15, %if18.us141 ], [ %28, %endif48.us156 ] ; [#uses = 2, type = i64]
  %29 = icmp ult i64 %j.1.us160, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %29, label %bounds.ok15.us138, label %bounds.ok65

forinc22.us161:                                   ; preds = %bounds.ok42.us148
  %30 = add nuw i64 %i.0131.us144, 1              ; [#uses = 2]
  %31 = icmp eq i64 %30, %3                       ; [#uses = 1]
  br i1 %31, label %if24, label %endif25.us143

if24:                                             ; preds = %forinc22.us161, %bounds.ok15.us
  %.lcssa127 = phi i64 [ %j.0137.us, %bounds.ok15.us ], [ %16, %forinc22.us161 ] ; [#uses = 4, type = i64]
  %bounds.cmp.lo31.not = icmp ult i64 %haystack_arg.fca.0.extract, %.lcssa127 ; [#uses = 1]
  br i1 %bounds.cmp.lo31.not, label %bounds.fail28, label %bounds.ok27

bounds.ok27:                                      ; preds = %if24
  %lowerbound33 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %.lcssa127 ; [#uses = 1, type = i8*]
  %32 = sub i64 %haystack_arg.fca.0.extract, %.lcssa127 ; [#uses = 1]
  %33 = insertvalue { i64, i8* } undef, i64 %32, 0 ; [#uses = 1]
  %34 = insertvalue { i64, i8* } %33, i8* %lowerbound33, 1 ; [#uses = 1]
  ret { i64, i8* } %34

bounds.fail28:                                    ; preds = %if24
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.17, i32 0, i32 0) }, i32 2040, i64 %.lcssa127, i64 %haystack_arg.fca.0.extract, i64 %haystack_arg.fca.0.extract) #3
  unreachable

bounds.fail43:                                    ; preds = %bounds.ok37.us146
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.17, i32 0, i32 0) }, i32 2041, i64 %needle_arg.fca.0.extract, i64 %needle_arg.fca.0.extract) #3
  unreachable

bounds.fail38.loopexit:                           ; preds = %endif25.us143
  %35 = icmp ugt i64 %haystack_arg.fca.0.extract, %16 ; [#uses = 1]
  %umax.le = select i1 %35, i64 %haystack_arg.fca.0.extract, i64 %16 ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.17, i32 0, i32 0) }, i32 2041, i64 %umax.le, i64 %haystack_arg.fca.0.extract) #3
  unreachable

bounds.fail56:                                    ; preds = %andand.us150
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.17, i32 0, i32 0) }, i32 2047, i64 %24, i64 %needle_arg.fca.0.extract) #3
  unreachable

bounds.ok65:                                      ; preds = %forinc.us158, %if18.us, %bounds.ok9
  %lowerbound71 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %haystack_arg.fca.0.extract ; [#uses = 1, type = i8*]
  %36 = insertvalue { i64, i8* } { i64 0, i8* undef }, i8* %lowerbound71, 1 ; [#uses = 1]
  ret { i64, i8* } %36
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAhZQkFNaNbNdNiNfMKQsZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #2 {
  %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 = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T9binaryFunVAyaa6_61203d3d2062VQta1_61VQBba1_62Z__TQByThThZQCgFNaNbNiNfKhKhZb(i8* dereferenceable(1) %__b, i8* dereferenceable(1) %__a) local_unnamed_addr #2 {
  %1 = load i8, i8* %__a, align 1                 ; [#uses = 1]
  %2 = load i8, i8* %__b, align 1                 ; [#uses = 1]
  %3 = icmp eq i8 %1, %2                          ; [#uses = 1]
  ret i1 %3
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.array.Appender!(string[]).Appender" @_D3std5array__T8appenderTAAyaZQpFNaNbNfZSQBnQBm__T8AppenderTQBjZQo() local_unnamed_addr #2 {
  %arr.i.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 3, size/byte = 16]
  %arr.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 4, size/byte = 16]
  %1 = bitcast { i64, { i64, i8* }* }* %arr.i to i8* ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %1)
  %2 = bitcast { i64, { i64, i8* }* }* %arr.i to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %2, i8 0, i64 16, i1 false)
  %.gc_struct.i = tail call noalias i8* @_d_newitemT(%object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ to %object.TypeInfo*)) #1 ; [#uses = 3]
  %3 = bitcast { i64, { i64, i8* }* }* %arr.i.i to i8* ; [#uses = 2]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %.gc_struct.i, i8 0, i64 32, i1 false)
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %3)
  %4 = bitcast { i64, { i64, i8* }* }* %arr.i.i to { i64, i8* }* ; [#uses = 1]
  %5 = bitcast { i64, { i64, i8* }* }* %arr.i.i to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %5, i8 0, i64 16, i1 false)
  %6 = call i64 @_d_arraysetcapacity(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), i64 0, { i64, i8* }* nonnull %4) #4 ; [#uses = 2]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %3)
  %.not = icmp eq i64 %6, 0                       ; [#uses = 1]
  br i1 %.not, label %_D3std5array__T8AppenderTAAyaZQp6__ctorMFNaNbNcNeQyZSQBzQBy__TQBvTQBpZQCd.exit, label %if.i

if.i:                                             ; preds = %0
  %arr_arg.fca.0.gep.i = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %7 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %6, { i64, { i64, i8* }* }* nonnull dereferenceable(16) %arr.i) #14 ; [#uses = 0]
  %.len3.pre.i = load i64, i64* %arr_arg.fca.0.gep.i, align 8 ; [#uses = 1]
  br label %_D3std5array__T8AppenderTAAyaZQp6__ctorMFNaNbNcNeQyZSQBzQBy__TQBvTQBpZQCd.exit

_D3std5array__T8AppenderTAAyaZQp6__ctorMFNaNbNcNeQyZSQBzQBy__TQBvTQBpZQCd.exit: ; preds = %0, %if.i
  %.len3.i = phi i64 [ %.len3.pre.i, %if.i ], [ 0, %0 ] ; [#uses = 1, type = i64]
  %8 = bitcast i8* %.gc_struct.i to %"std.array.Appender!(string[]).Appender.Data"* ; [#uses = 1]
  %9 = bitcast i8* %.gc_struct.i to i64*          ; [#uses = 1]
  store i64 %.len3.i, i64* %9, align 8
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %1)
  %.fca.0.insert = insertvalue %"std.array.Appender!(string[]).Appender" undef, %"std.array.Appender!(string[]).Appender.Data"* %8, 0 ; [#uses = 1]
  ret %"std.array.Appender!(string[]).Appender" %.fca.0.insert
}

; [#uses = 0]
; 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 #2 {
  tail call void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 1) #2
  %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.20, i32 0, i32 0) }, i32 3515, i64 -1, i64 %5) #3
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, { i64, i8* }* } @_D3std5array__T8AppenderTAAyaZQp4dataMNgFNaNbNdNiNeZANgAya(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #2 {
  %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 = 0]
; 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 #2 {
  %arr.i = alloca { i64, { i64, i8* }* }, align 8 ; [#uses = 4, size/byte = 16]
  %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 = 5]
  %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*)) #1 ; [#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 = 2]
  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 = bitcast { i64, { i64, i8* }* }* %arr.i to i8* ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %5)
  %arr_arg.fca.0.gep.i = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %arr_arg.fca.0.extract, i64* %arr_arg.fca.0.gep.i, align 8
  %arr_arg.fca.1.gep.i = getelementptr inbounds { i64, { i64, i8* }* }, { i64, { i64, i8* }* }* %arr.i, i64 0, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %6 = bitcast { i64, i8* }** %arr_arg.fca.1.gep.i to i64* ; [#uses = 1]
  store i64 %3, i64* %6, align 8
  %7 = bitcast { i64, { i64, i8* }* }* %arr.i to { i64, i8* }* ; [#uses = 1]
  %8 = call i64 @_d_arraysetcapacity(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D13TypeInfo_AAya6__initZ to %object.TypeInfo*), i64 0, { i64, i8* }* nonnull %7) #4 ; [#uses = 2]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %5)
  %9 = icmp ugt i64 %8, %arr_arg.fca.0.extract    ; [#uses = 1]
  br i1 %9, label %if, label %endif

if:                                               ; preds = %0
  %10 = call i64 @_D4core8internal5array8capacity__T22_d_arraysetlengthTImplHTAAyaTQeZ18_d_arraysetlengthTFNaNbNeMNkKQBnmZm(i64 %8, { i64, { i64, i8* }* }* nonnull dereferenceable(16) %arr) #14 ; [#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]
  %11 = 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"**]
  %12 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %11, align 8 ; [#uses = 1]
  %13 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %12, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len3, i64* %13, 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) #2 {
  %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 = 3]
  %.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 = 2]
  %.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]
  %.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 = 2]
  %.not.i = icmp eq i64 %.unpack, %.unpack7       ; [#uses = 1]
  br i1 %.not.i, label %endif.i, label %andandend2

endif.i:                                          ; preds = %andand
  %.not29.i = icmp eq i64 %.unpack, 0             ; [#uses = 1]
  br i1 %.not29.i, label %andand1, label %forbody.i

forcond.i:                                        ; preds = %forbody.i
  %exitcond.not.i = icmp eq i64 %11, %.unpack     ; [#uses = 1]
  br i1 %exitcond.not.i, label %andand1, label %forbody.i

forbody.i:                                        ; preds = %endif.i, %forcond.i
  %__key240.027.i = phi i64 [ %11, %forcond.i ], [ 0, %endif.i ] ; [#uses = 5, type = i64]
  %.elt.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.unpack5, i64 %__key240.027.i, i32 0 ; [#uses = 1, type = i64*]
  %.unpack.i = load i64, i64* %.elt.i, align 8    ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack.i, 0 ; [#uses = 1]
  %.elt20.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.unpack5, i64 %__key240.027.i, i32 1 ; [#uses = 1, type = i8**]
  %.unpack21.i = load i8*, i8** %.elt20.i, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack21.i, 1 ; [#uses = 1]
  %.elt22.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.unpack9, i64 %__key240.027.i, i32 0 ; [#uses = 1, type = i64*]
  %.unpack23.i = load i64, i64* %.elt22.i, align 8 ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.unpack23.i, 0 ; [#uses = 1]
  %.elt24.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.unpack9, i64 %__key240.027.i, i32 1 ; [#uses = 1, type = i8**]
  %.unpack25.i = load i8*, i8** %.elt24.i, align 8 ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack25.i, 1 ; [#uses = 1]
  %10 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %9, { i64, i8* } %7) #4 ; [#uses = 1]
  %11 = add nuw i64 %__key240.027.i, 1            ; [#uses = 2]
  br i1 %10, label %forcond.i, label %andandend2

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D4core8internal5array8equality__T8__equalsTxAyaTxQfZQtFNaNbNiNfMAxQwMQfZb({ i64, { i64, i8* }* } %rhs_arg, { i64, { i64, i8* }* } %lhs_arg) local_unnamed_addr #2 {
  %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, %endif, %0
  %merge = phi i1 [ false, %0 ], [ true, %endif ], [ true, %forcond ], [ false, %forbody ] ; [#uses = 1, type = i1]
  ret i1 %merge

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

forbody.lr.ph:                                    ; 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 %forbody

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

forbody:                                          ; preds = %forcond, %forbody.lr.ph
  %__key240.027 = phi i64 [ 0, %forbody.lr.ph ], [ %6, %forcond ] ; [#uses = 5, type = i64]
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i, i64 %__key240.027, 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]
  %.elt20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i, i64 %__key240.027, i32 1 ; [#uses = 1, type = i8**]
  %.unpack21 = load i8*, i8** %.elt20, align 8    ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack21, 1 ; [#uses = 1]
  %.elt22 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i26, i64 %__key240.027, i32 0 ; [#uses = 1, type = i64*]
  %.unpack23 = load i64, i64* %.elt22, align 8    ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack23, 0 ; [#uses = 1]
  %.elt24 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r_arg.fca.1.extract.i26, i64 %__key240.027, i32 1 ; [#uses = 1, type = i8**]
  %.unpack25 = load i8*, i8** %.elt24, align 8    ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack25, 1 ; [#uses = 1]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #4 ; [#uses = 1]
  %6 = add nuw i64 %__key240.027, 1               ; [#uses = 2]
  br i1 %5, 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) #2 {
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 #1

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D6object__T8capacityTAyaZQoFNaNbNdNeAQqZm({ i64, { i64, i8* }* } %arr_arg) local_unnamed_addr #2 {
  %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) #4 ; [#uses = 1]
  ret i64 %2
}

; [#uses = 4]
; 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 #9 {
  %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) #4 ; [#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 #2 {
  %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) #4
  br label %endif

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

; [#uses = 4]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp13ensureAddableMFNaNbNfmZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg, i64 %nelems_arg) local_unnamed_addr #2 {
  %.sret_tmp = alloca %core.memory.BlkInfo_, align 8 ; [#uses = 3, size/byte = 24]
  %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*)) #1 ; [#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 = 4, 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 = 5]
  %7 = add i64 %.len, %nelems_arg                 ; [#uses = 5]
  %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 = 4]
  %.not30 = icmp ult i64 %9, %7                   ; [#uses = 1]
  br i1 %.not30, label %endif4, label %if3

if3:                                              ; preds = %endif
  ret void

endif4:                                           ; preds = %endif
  %10 = icmp eq i64 %9, 0                         ; [#uses = 1]
  br i1 %10, label %if.i, label %endif.i

if.i:                                             ; preds = %endif4
  %11 = icmp ugt i64 %7, 8                        ; [#uses = 1]
  %spec.select.i.i = select i1 %11, i64 %7, i64 8 ; [#uses = 1]
  br label %_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm.exit

endif.i:                                          ; preds = %endif4
  %12 = shl i64 %9, 4                             ; [#uses = 1]
  %13 = tail call i64 @llvm.ctlz.i64(i64 %12, i1 immarg true) #11, !range !37 ; [#uses = 1]
  %14 = trunc i64 %13 to i16                      ; [#uses = 1]
  %.rhs.trunc.i = sub nuw nsw i16 64, %14         ; [#uses = 1]
  %15 = udiv i16 1000, %.rhs.trunc.i              ; [#uses = 1]
  %.zext.i = zext i16 %15 to i64                  ; [#uses = 2]
  %16 = icmp ult i64 %.zext.i, 100                ; [#uses = 1]
  %17 = select i1 %16, i64 %.zext.i, i64 100      ; [#uses = 1]
  %spec.store.select.i = add nuw nsw i64 %17, 100 ; [#uses = 1]
  %18 = mul i64 %spec.store.select.i, %9          ; [#uses = 1]
  %19 = add i64 %18, 99                           ; [#uses = 1]
  %20 = udiv i64 %19, 100                         ; [#uses = 2]
  %21 = icmp ugt i64 %20, %7                      ; [#uses = 1]
  %b_arg.a_arg.i.i = select i1 %21, i64 %20, i64 %7 ; [#uses = 1]
  br label %_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm.exit

_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm.exit: ; preds = %endif.i, %if.i
  %22 = phi i64 [ %spec.select.i.i, %if.i ], [ %b_arg.a_arg.i.i, %endif.i ] ; [#uses = 2, type = i64]
  %23 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %5, i64 0, i32 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1, !range !18     ; [#uses = 1]
  %.not31 = icmp eq i8 %24, 0                     ; [#uses = 1]
  br i1 %.not31, label %endif6, label %if5

if5:                                              ; preds = %_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm.exit
  %25 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %5, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %26 = bitcast { i64, i8* }** %25 to i8**        ; [#uses = 1]
  %.ptr1.i39 = load i8*, i8** %26, align 8        ; [#uses = 1]
  %27 = shl i64 %nelems_arg, 4                    ; [#uses = 1]
  %28 = sub i64 %22, %.len                        ; [#uses = 1]
  %29 = shl i64 %28, 4                            ; [#uses = 1]
  %30 = tail call i64 @gc_extend(i8* %.ptr1.i39, i64 %27, i64 %29, %object.TypeInfo* null) #4 ; [#uses = 2]
  %.not34 = icmp eq i64 %30, 0                    ; [#uses = 1]
  br i1 %.not34, label %endif6, label %if7

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

endif6:                                           ; preds = %if5, %_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm.exit
  %34 = tail call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %22, i64 16) #11 ; [#uses = 2]
  %35 = extractvalue { i64, i1 } %34, 1           ; [#uses = 1]
  br i1 %35, label %assertFailed, label %endif11

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

endif11:                                          ; preds = %endif6
  %36 = extractvalue { i64, i1 } %34, 0           ; [#uses = 1]
  call void @gc_qalloc(%core.memory.BlkInfo_* noalias nonnull sret align 8 %.sret_tmp, i64 %36, i32 0, %object.TypeInfo* null) #4
  %.frame.sroa.16.40..sroa_idx = getelementptr inbounds %core.memory.BlkInfo_, %core.memory.BlkInfo_* %.sret_tmp, i64 0, i32 0 ; [#uses = 1, type = i8**]
  %.frame.sroa.16.40.copyload = load i8*, i8** %.frame.sroa.16.40..sroa_idx, align 8 ; [#uses = 2]
  %.frame.sroa.19.40..sroa_idx49 = getelementptr inbounds %core.memory.BlkInfo_, %core.memory.BlkInfo_* %.sret_tmp, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %.frame.sroa.19.40.copyload = load i64, i64* %.frame.sroa.19.40..sroa_idx49, align 8 ; [#uses = 1]
  %37 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %38 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %37, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %39 = lshr i64 %.frame.sroa.19.40.copyload, 4   ; [#uses = 1]
  store i64 %39, i64* %38, align 8
  %.not33 = icmp eq i64 %.len, 0                  ; [#uses = 1]
  br i1 %.not33, label %endif16, label %if15

if15:                                             ; preds = %endif11
  %40 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %41 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %40, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %42 = bitcast { i64, i8* }** %41 to i8**        ; [#uses = 1]
  %.ptr1.i = load i8*, i8** %42, align 8          ; [#uses = 1]
  %43 = shl i64 %.len, 4                          ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.frame.sroa.16.40.copyload, i8* align 1 %.ptr1.i, i64 %43, i1 false) #4
  br label %endif16

endif16:                                          ; preds = %endif11, %if15
  %44 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 2]
  %45 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %44, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %45, align 8
  %46 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %44, i64 0, i32 1, i32 1 ; [#uses = 1, type = { i64, i8* }**]
  %47 = bitcast { i64, i8* }** %46 to i8**        ; [#uses = 1]
  store i8* %.frame.sroa.16.40.copyload, i8** %47, align 8
  %48 = load %"std.array.Appender!(string[]).Appender.Data"*, %"std.array.Appender!(string[]).Appender.Data"** %1, align 8 ; [#uses = 1]
  %49 = getelementptr inbounds %"std.array.Appender!(string[]).Appender.Data", %"std.array.Appender!(string[]).Appender.Data"* %48, i64 0, i32 2 ; [#uses = 1, type = i8*]
  store i8 1, i8* %49, 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 #2 {
  %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 #2 {
  %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 = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5array__T19appenderNewCapacityVmi16ZQBbFNaNbNiNfmmZm(i64 %reqLen_arg, i64 %curLen_arg) local_unnamed_addr #2 {
  %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) #11, !range !37 ; [#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]
declare i64 @gc_extend(i8*, i64, i64, %object.TypeInfo*) local_unnamed_addr #4

; [#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 #10 {
  %1 = tail call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %x_arg, i64 %y_arg) #11 ; [#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 !18 ; [#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) #11

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5array__T8AppenderTAAyaZQp5clearMFNaNbNiNeZv(%"std.array.Appender!(string[]).Appender"* nonnull %.this_arg) local_unnamed_addr #2 {
  %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 #2 {
  %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.21, i32 0, i32 0) }, i64 3644, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.20, i32 0, i32 0) }) #13
  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.22, i32 0, i32 0) }, i64 3648, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.20, i32 0, i32 0) }) #13
  unreachable

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

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

; [#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 #9 {
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) #4
  %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) #9 ; [#uses = 1]
  call void @_D4core8internal5array5utils11gcStatsPureFNaNbZSQBu6memory2GC5Stats(%core.memory.GC.Stats* noalias nonnull sret align 8 %.sret_tmp1) #4
  %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.23, i32 0, i32 0) }, { i64, i8* } %funcname_arg, i32 %line_arg, { i64, i8* } %7) #4 ; [#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.24, i32 0, i32 0) }, i32 86) #3
  unreachable

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

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

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

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

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

; [#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 #2 {
  %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) #4
  %2 = bitcast { i64, i8* }* %_param_1 to <2 x i64>* ; [#uses = 1]
  %3 = load <2 x i64>, <2 x i64>* %2, align 8     ; [#uses = 1]
  %4 = bitcast { i64, i8* }* %chunk_arg to <2 x i64>* ; [#uses = 1]
  store <2 x i64> %3, <2 x i64>* %4, 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 #2 {
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) #11

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm10comparison__T3maxTmTmZQjFNaNbNiNfmmZm(i64 %b_arg, i64 %a_arg) local_unnamed_addr #2 {
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 #2 {
  %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 #2 {
  %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 #2 {
  %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) #4
  %2 = bitcast { i64, i8* }* %_param_1 to <2 x i64>* ; [#uses = 1]
  %3 = load <2 x i64>, <2 x i64>* %2, align 8     ; [#uses = 1]
  %4 = bitcast { i64, i8* }* %chunk to <2 x i64>* ; [#uses = 1]
  store <2 x i64> %3, <2 x i64>* %4, 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 #2 {
  %.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) #4 ; [#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 #2 {
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 #2 {
  %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) #4
  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 #2 {
  %1 = bitcast { i64, i8* }* %_param_0 to <2 x i64>* ; [#uses = 1]
  %2 = load <2 x i64>, <2 x i64>* %1, align 8     ; [#uses = 1]
  %3 = bitcast %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %.this_arg to <2 x i64>* ; [#uses = 1]
  store <2 x i64> %2, <2 x i64>* %3, align 8
  ret %"core.internal.lifetime.emplaceRef!(string, string, string).emplaceRef.S"* %.this_arg
}

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

; [#uses = 0]
; Function Attrs: alwaysinline uwtable
define weak_odr { i64, i8* }* @_D4core8internal5array8equality__T2atTxAyaZQjFNaNbNcNiNeAxQtmZxQy(i64 %i_arg, { i64, { i64, i8* }* } %r_arg) local_unnamed_addr #10 {
  %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 = 1]
; Function Attrs: uwtable
declare { i64, i8* } @_d_newarrayT(%object.TypeInfo*, i64) local_unnamed_addr #1

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTAyaZQjMFNfMQlZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, { i64, i8* } %writeme_arg) local_unnamed_addr #2 {
  %writeme_arg.fca.0.extract = extractvalue { i64, i8* } %writeme_arg, 0 ; [#uses = 4]
  %writeme_arg.fca.1.extract = extractvalue { i64, i8* } %writeme_arg, 1 ; [#uses = 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]
  br i1 %3, label %if, label %forcond.preheader

forcond.preheader:                                ; preds = %0
  %.not11 = icmp eq i64 %writeme_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not11, label %endif2, label %forbody

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 @fwrite(i8* %writeme_arg.fca.1.extract, i64 1, i64 %writeme_arg.fca.0.extract, %core.stdc.stdio._IO_FILE* %7) #4 ; [#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.10, i32 0, i32 0) }) #13
  unreachable

endif2:                                           ; preds = %forbody, %forcond.preheader, %if
  ret void

forbody:                                          ; preds = %forcond.preheader, %forbody
  %__key252.010 = phi i64 [ %11, %forbody ], [ 0, %forcond.preheader ] ; [#uses = 2, type = i64]
  %9 = getelementptr inbounds i8, i8* %writeme_arg.fca.1.extract, i64 %__key252.010 ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTyaZQiMFNfyaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %10) #4
  %11 = add nuw i64 %__key252.010, 1              ; [#uses = 2]
  %exitcond.not = icmp eq i64 %11, %writeme_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %endif2, label %forbody
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %c_arg) local_unnamed_addr #2 {
  %numCodeUnits.i = alloca i64, align 8           ; [#uses = 3, size/byte = 8]
  %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) #4
  %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) #4 ; [#uses = 1]
  %6 = tail call i32 @fputc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %5) #4 ; [#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) #4 ; [#uses = 1]
  %9 = tail call i32 @fputwc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %8) #4 ; [#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 = 2]
  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 = load i8, i8* %19, align 1                 ; [#uses = 2]
  %21 = icmp sgt i8 %20, -1                       ; [#uses = 1]
  br i1 %21, label %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit, label %else.i

else.i:                                           ; preds = %bounds.ok
  %22 = tail call i32 @_D3std3utf10strideImplFNaNeamZk(i64 0, i8 zeroext %20) #4 ; [#uses = 1]
  %phi.cast = zext i32 %22 to i64                 ; [#uses = 1]
  %.pre = load i64, i64* %14, align 8             ; [#uses = 1]
  br label %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit

_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit:         ; preds = %bounds.ok, %else.i
  %23 = phi i64 [ %.pre, %else.i ], [ %18, %bounds.ok ] ; [#uses = 4, type = i64]
  %24 = phi i64 [ %phi.cast, %else.i ], [ 1, %bounds.ok ] ; [#uses = 1, type = i64]
  %25 = icmp eq i64 %23, %24                      ; [#uses = 1]
  br i1 %25, label %if7, label %endif

if7:                                              ; preds = %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit
  %bounds.cmp.up = icmp ult i64 %23, 5            ; [#uses = 1]
  br i1 %bounds.cmp.up, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %if7
  %26 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %23, i64* %26, align 8
  %27 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %19, i8** %27, align 8
  %28 = bitcast i64* %numCodeUnits.i to i8*       ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %28)
  store i64 0, i64* %numCodeUnits.i, align 8
  %29 = call i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNeKQmJmZw(i64* nonnull dereferenceable(8) %numCodeUnits.i, { i64, i8* }* nonnull dereferenceable(16) %str) #4 ; [#uses = 1]
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %28)
  %30 = getelementptr inbounds [1 x i32], [1 x i32]* %wbuf, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 65535, i32* %30, align 4
  %31 = call i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG1wwZm(i32 %29, [1 x i32]* nonnull dereferenceable(4) %wbuf) #2 ; [#uses = 2]
  %.not = icmp eq i64 %31, 0                      ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %bounds.ok9
  %.not25 = icmp eq i64 %31, 1                    ; [#uses = 1]
  %32 = load i32, i32* %30, align 4               ; [#uses = 1]
  %33 = call %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #4 ; [#uses = 1]
  %34 = call i32 @fputwc_unlocked(i32 %32, %core.stdc.stdio._IO_FILE* %33) #4 ; [#uses = 0]
  br i1 %.not25, label %endfor, label %bounds.ok12.us

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

endfor:                                           ; preds = %forbody.lr.ph, %bounds.ok9
  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.10, i32 0, i32 0) }, i32 3305, i64 0, i64 %23, i64 4) #3
  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.10, i32 0, i32 0) }, i32 3301, i64 %15, i64 4) #3
  unreachable

endif:                                            ; preds = %if1, %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit, %endfor, %if4, %if
  ret void
}

; [#uses = 0]
; 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 #2 {
  %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) #4 ; [#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 #2 {
  %.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) #13
  unreachable

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTyaZQiMFNfyaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %c_arg) local_unnamed_addr #2 {
  %numCodeUnits.i = alloca i64, align 8           ; [#uses = 3, size/byte = 8]
  %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) #4
  %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) #4 ; [#uses = 1]
  %6 = tail call i32 @fputc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %5) #4 ; [#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) #4 ; [#uses = 1]
  %9 = tail call i32 @fputwc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %8) #4 ; [#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 = 2]
  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 = load i8, i8* %19, align 1                 ; [#uses = 2]
  %21 = icmp sgt i8 %20, -1                       ; [#uses = 1]
  br i1 %21, label %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit, label %else.i

else.i:                                           ; preds = %bounds.ok
  %22 = tail call i32 @_D3std3utf10strideImplFNaNeamZk(i64 0, i8 zeroext %20) #4 ; [#uses = 1]
  %phi.cast = zext i32 %22 to i64                 ; [#uses = 1]
  %.pre = load i64, i64* %14, align 8             ; [#uses = 1]
  br label %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit

_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit:         ; preds = %bounds.ok, %else.i
  %23 = phi i64 [ %.pre, %else.i ], [ %18, %bounds.ok ] ; [#uses = 4, type = i64]
  %24 = phi i64 [ %phi.cast, %else.i ], [ 1, %bounds.ok ] ; [#uses = 1, type = i64]
  %25 = icmp eq i64 %23, %24                      ; [#uses = 1]
  br i1 %25, label %if7, label %endif

if7:                                              ; preds = %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit
  %bounds.cmp.up = icmp ult i64 %23, 5            ; [#uses = 1]
  br i1 %bounds.cmp.up, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %if7
  %26 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %23, i64* %26, align 8
  %27 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %str, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %19, i8** %27, align 8
  %28 = bitcast i64* %numCodeUnits.i to i8*       ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %28)
  store i64 0, i64* %numCodeUnits.i, align 8
  %29 = call i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNeKQmJmZw(i64* nonnull dereferenceable(8) %numCodeUnits.i, { i64, i8* }* nonnull dereferenceable(16) %str) #4 ; [#uses = 1]
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %28)
  %30 = getelementptr inbounds [1 x i32], [1 x i32]* %wbuf, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 65535, i32* %30, align 4
  %31 = call i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG1wwZm(i32 %29, [1 x i32]* nonnull dereferenceable(4) %wbuf) #4 ; [#uses = 2]
  %.not = icmp eq i64 %31, 0                      ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %bounds.ok9
  %.not25 = icmp eq i64 %31, 1                    ; [#uses = 1]
  %32 = load i32, i32* %30, align 4               ; [#uses = 1]
  %33 = call %core.stdc.stdio._IO_FILE* @_D3std5stdio4File17LockingTextWriter7handle_MFNdNeZPS4core4stdcQCf8_IO_FILE(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #4 ; [#uses = 1]
  %34 = call i32 @fputwc_unlocked(i32 %32, %core.stdc.stdio._IO_FILE* %33) #4 ; [#uses = 0]
  br i1 %.not25, label %endfor, label %bounds.ok12.us

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

endfor:                                           ; preds = %forbody.lr.ph, %bounds.ok9
  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.10, i32 0, i32 0) }, i32 3305, i64 0, i64 %23, i64 4) #3
  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.10, i32 0, i32 0) }, i32 3301, i64 %15, i64 4) #3
  unreachable

endif:                                            ; preds = %if1, %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit, %endfor, %if4, %if
  ret void
}

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

; [#uses = 3]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #6 {
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 2]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std9exception14ErrnoException7__ClassZ) #1 ; [#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
  %a_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %msg_arg, 0 ; [#uses = 2]
  %4 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract.i.i) #4 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %4, 1     ; [#uses = 2]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i.i, i8* nonnull align 1 %msg_arg.fca.1.extract, i64 %a_arg.fca.0.extract.i.i, i1 false) #4
  %.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* [ %.ptr.i.i, %condtrue ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, 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) #4 ; [#uses = 0]
  %6 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %6) #3
  unreachable
}

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T6strideTAaZQlFNaNfQkZk({ i64, i8* } %str_arg) local_unnamed_addr #2 {
  %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) #4 ; [#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.25, i32 0, i32 0) }, i32 403, i64 0, i64 0) #3
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNfKQmZw({ i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #2 {
  %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) #4 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i64 @_D3std3utf__T6encodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDdFNaNfJG1wwZm(i32 %c_arg, [1 x i32]* dereferenceable(4) %buf) local_unnamed_addr #2 {
arrayinit.cond:
  %.lval_copy_for_ImplicitByvalRewrite.i = alloca { i64, i8* }, align 8 ; [#uses = 4, size/byte = 16]
  %arrayliteral.i = alloca [1 x i32], align 4     ; [#uses = 2, size/byte = 4]
  %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 = bitcast { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i to i8* ; [#uses = 1]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %4)
  %5 = bitcast [1 x i32]* %arrayliteral.i to i8*  ; [#uses = 1]
  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %5)
  %.newclass_gc_alloc.i = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #1 ; [#uses = 4]
  %.newclass_gc.i = bitcast %object.Object* %.newclass_gc_alloc.i to %std.utf.UTFException* ; [#uses = 2]
  %vtbl.i = bitcast %object.Object* %.newclass_gc_alloc.i to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl.i, align 8
  %6 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %6, align 8
  %7 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 1 ; [#uses = 1, type = %object.Object*]
  %8 = bitcast %object.Object* %7 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %8, 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.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 40, i64* %msg.sroa.0.0..sroa_idx.i, align 8
  %msg.sroa.2.0..sroa_idx1.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.28, i64 0, i64 0), i8** %msg.sroa.2.0..sroa_idx1.i, align 8
  %9 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCnQCmQCl(%std.utf.UTFException* nonnull returned %.newclass_gc.i, %object.Throwable* null, i64 2301, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.25, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite.i) #4 ; [#uses = 0]
  %10 = load [11 x i8*]*, [11 x i8*]** %vtbl.i, align 8 ; [#uses = 1]
  %"setSequence@vtbl.i" = getelementptr inbounds [11 x i8*], [11 x i8*]* %10, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %11 = bitcast i8** %"setSequence@vtbl.i" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %12 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %11, align 8 ; [#uses = 1]
  %13 = getelementptr inbounds [1 x i32], [1 x i32]* %arrayliteral.i, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 %c_arg, i32* %13, align 4
  %14 = insertvalue { i64, i32* } { i64 1, i32* undef }, i32* %13, 1 ; [#uses = 1]
  %15 = call %std.utf.UTFException* %12(%std.utf.UTFException* nonnull %.newclass_gc.i, { i64, i32* } %14) ; [#uses = 1]
  %16 = bitcast %std.utf.UTFException* %15 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %16) #3
  unreachable

else:                                             ; preds = %arrayinit.cond
  %17 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %c_arg) #4 ; [#uses = 1]
  br i1 %17, 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.25, i32 0, i32 0) }, i32 2506) #3
  unreachable

endif:                                            ; preds = %else
  store i32 %c_arg, i32* %0, align 4
  ret i64 1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAaZQkFNaNbNdNiNfMKQsZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #2 {
  %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]
declare i32 @_D3std3utf10strideImplFNaNeamZk(i64, i8 zeroext) local_unnamed_addr #4

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T11decodeFrontVEQBa8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAaZQDnFNaNeKQmJmZw(i64* dereferenceable(8) %numCodeUnits, { i64, i8* }* dereferenceable(16) %str) local_unnamed_addr #2 {
  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.25, i32 0, i32 0) }, i32 1292, i64 0, i64 0) #3
  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) #4 ; [#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.25, i32 0, i32 0) }, i32 1299, i64 %11, i64 %.len14, i64 %.len14) #3
  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) #4 ; [#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.25, i32 0, i32 0) }, i32 1285) #3
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.25, i32 0, i32 0) }, i32 1281) #3
  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 #2 {
  %.frame = alloca %nest.decodeImpl, 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, %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 = 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* %.frame to i8*   ; [#uses = 1]
  %8 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %7) #2 ; [#uses = 1]
  %9 = bitcast %std.utf.UTFException* %8 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %9) #3
  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* %.frame to i8*  ; [#uses = 1]
  %12 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %11) #2 ; [#uses = 1]
  %13 = bitcast %std.utf.UTFException* %12 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %13) #3
  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* %.frame to i8*  ; [#uses = 1]
  %19 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %18) #2 ; [#uses = 1]
  %20 = bitcast %std.utf.UTFException* %19 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %20) #3
  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* %.frame to i8*  ; [#uses = 1]
  %28 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %27) #2 ; [#uses = 1]
  %29 = bitcast %std.utf.UTFException* %28 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %29) #3
  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* %.frame to i8*  ; [#uses = 1]
  %34 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %33) #2 ; [#uses = 1]
  %35 = bitcast %std.utf.UTFException* %34 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %35) #3
  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* %.frame to i8*  ; [#uses = 1]
  %41 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %40) #2 ; [#uses = 1]
  %42 = bitcast %std.utf.UTFException* %41 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %42) #3
  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* %.frame to i8*  ; [#uses = 1]
  %51 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %50) #2 ; [#uses = 1]
  %52 = bitcast %std.utf.UTFException* %51 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %52) #3
  unreachable

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

if25:                                             ; preds = %endif23
  %54 = bitcast %nest.decodeImpl* %.frame to i8*  ; [#uses = 1]
  %55 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %54) #2 ; [#uses = 1]
  %56 = bitcast %std.utf.UTFException* %55 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %56) #3
  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* %.frame to i8*  ; [#uses = 1]
  %61 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %60) #2 ; [#uses = 1]
  %62 = bitcast %std.utf.UTFException* %61 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %62) #3
  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* %.frame to i8*  ; [#uses = 1]
  %68 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %67) #2 ; [#uses = 1]
  %69 = bitcast %std.utf.UTFException* %68 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %69) #3
  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* %.frame to i8*  ; [#uses = 1]
  %76 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %75) #2 ; [#uses = 1]
  %77 = bitcast %std.utf.UTFException* %76 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %77) #3
  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* %.frame to i8*  ; [#uses = 1]
  %81 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %80) #2 ; [#uses = 1]
  %82 = bitcast %std.utf.UTFException* %81 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %82) #3
  unreachable

endif41:                                          ; preds = %endif38
  ret i32 %72

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

; [#uses = 3]
declare zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32) local_unnamed_addr #4

; [#uses = 10]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #2 {
bounds.ok.i:
  %sequence.i = alloca [4 x i32], align 4         ; [#uses = 6, size/byte = 16]
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %0 = bitcast i8* %length to i64*                ; [#uses = 1]
  %1 = load i64, i64* %0, align 8                 ; [#uses = 9]
  %2 = load i8*, i8** %pstr, align 8              ; [#uses = 7]
  %3 = bitcast [4 x i32]* %sequence.i to i8*      ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %3)
  %exitcond.not.i = icmp eq i64 %1, 0             ; [#uses = 1]
  br i1 %exitcond.not.i, label %bounds.fail3.i, label %bounds.ok2.i

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

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

bounds.ok9.i:                                     ; preds = %bounds.ok2.i
  %7 = getelementptr inbounds i8, i8* %2, i64 1   ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %9 = and i8 %8, -64                             ; [#uses = 1]
  %10 = icmp eq i8 %9, -128                       ; [#uses = 1]
  br i1 %10, label %bounds.ok.i.1, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit: ; preds = %bounds.ok2.i.3, %bounds.ok2.i, %bounds.ok9.i.2, %bounds.ok2.i.2, %bounds.ok9.i.1, %bounds.ok2.i.1, %bounds.ok9.i
  %.lcssa = phi i64 [ 1, %bounds.ok2.i ], [ 1, %bounds.ok9.i ], [ 2, %bounds.ok2.i.1 ], [ 2, %bounds.ok9.i.1 ], [ 3, %bounds.ok2.i.2 ], [ 3, %bounds.ok9.i.2 ], [ 4, %bounds.ok2.i.3 ] ; [#uses = 2, type = i64]
  %.newclass_gc_alloc.i = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #1 ; [#uses = 4]
  %.newclass_gc.i = bitcast %object.Object* %.newclass_gc_alloc.i to %std.utf.UTFException* ; [#uses = 2]
  %vtbl.i = bitcast %object.Object* %.newclass_gc_alloc.i to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl.i, align 8
  %11 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %11, align 8
  %12 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 1 ; [#uses = 1, type = %object.Object*]
  %13 = bitcast %object.Object* %12 to i8*        ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %13, 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)
  %14 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNfAyamQemC6object9ThrowableZCQCmQClQCk(%std.utf.UTFException* nonnull returned %.newclass_gc.i, %object.Throwable* null, i64 1547, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.25, i32 0, i32 0) }, i64 %.lcssa, { i64, i8* } { i64 22, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.26, i32 0, i32 0) }) #4 ; [#uses = 0]
  %15 = load [11 x i8*]*, [11 x i8*]** %vtbl.i, align 8 ; [#uses = 1]
  %"setSequence@vtbl.i" = getelementptr inbounds [11 x i8*], [11 x i8*]* %15, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %16 = bitcast i8** %"setSequence@vtbl.i" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %17 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %16, align 8 ; [#uses = 1]
  %18 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %19 = insertvalue { i64, i32* } undef, i64 %.lcssa, 0 ; [#uses = 1]
  %20 = insertvalue { i64, i32* } %19, i32* %18, 1 ; [#uses = 1]
  %21 = call %std.utf.UTFException* %17(%std.utf.UTFException* nonnull %.newclass_gc.i, { i64, i32* } %20) ; [#uses = 1]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %3)
  ret %std.utf.UTFException* %21

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

bounds.ok2.i.1:                                   ; preds = %bounds.ok.i.1
  %22 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 1 ; [#uses = 1, type = i32*]
  %23 = getelementptr inbounds i8, i8* %2, i64 1  ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = zext i8 %24 to i32                        ; [#uses = 1]
  store i32 %25, i32* %22, align 4
  %26 = icmp ugt i64 %1, 2                        ; [#uses = 1]
  br i1 %26, label %bounds.ok9.i.1, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

bounds.ok9.i.1:                                   ; preds = %bounds.ok2.i.1
  %27 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = and i8 %28, -64                           ; [#uses = 1]
  %30 = icmp eq i8 %29, -128                      ; [#uses = 1]
  br i1 %30, label %bounds.ok.i.2, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

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

bounds.ok2.i.2:                                   ; preds = %bounds.ok.i.2
  %31 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 2 ; [#uses = 1, type = i32*]
  %32 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %34 = zext i8 %33 to i32                        ; [#uses = 1]
  store i32 %34, i32* %31, align 4
  %35 = icmp ugt i64 %1, 3                        ; [#uses = 1]
  br i1 %35, label %bounds.ok9.i.2, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

bounds.ok9.i.2:                                   ; preds = %bounds.ok2.i.2
  %36 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %38 = and i8 %37, -64                           ; [#uses = 1]
  %39 = icmp eq i8 %38, -128                      ; [#uses = 1]
  br i1 %39, label %bounds.ok.i.3, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

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

bounds.ok2.i.3:                                   ; preds = %bounds.ok.i.3
  %40 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 3 ; [#uses = 1, type = i32*]
  %41 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %42 = load i8, i8* %41, align 1                 ; [#uses = 1]
  %43 = zext i8 %42 to i32                        ; [#uses = 1]
  store i32 %43, i32* %40, align 4
  br label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit
}

; [#uses = 0]
; 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 #2 {
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.25, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #3
  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) #1 ; [#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.25, i32 0, i32 0) }, i64 %.lcssa, { i64, i8* } %msg_arg) #4 ; [#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 #2 {
bounds.ok.i:
  %sequence.i = alloca [4 x i32], align 4         ; [#uses = 6, size/byte = 16]
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %0 = bitcast i8* %length to i64*                ; [#uses = 1]
  %1 = load i64, i64* %0, align 8                 ; [#uses = 9]
  %2 = load i8*, i8** %pstr, align 8              ; [#uses = 7]
  %3 = bitcast [4 x i32]* %sequence.i to i8*      ; [#uses = 2]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %3)
  %exitcond.not.i = icmp eq i64 %1, 0             ; [#uses = 1]
  br i1 %exitcond.not.i, label %bounds.fail3.i, label %bounds.ok2.i

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

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

bounds.ok9.i:                                     ; preds = %bounds.ok2.i
  %7 = getelementptr inbounds i8, i8* %2, i64 1   ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %9 = and i8 %8, -64                             ; [#uses = 1]
  %10 = icmp eq i8 %9, -128                       ; [#uses = 1]
  br i1 %10, label %bounds.ok.i.1, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit: ; preds = %bounds.ok2.i.3, %bounds.ok2.i, %bounds.ok9.i.2, %bounds.ok2.i.2, %bounds.ok9.i.1, %bounds.ok2.i.1, %bounds.ok9.i
  %.lcssa = phi i64 [ 1, %bounds.ok2.i ], [ 1, %bounds.ok9.i ], [ 2, %bounds.ok2.i.1 ], [ 2, %bounds.ok9.i.1 ], [ 3, %bounds.ok2.i.2 ], [ 3, %bounds.ok9.i.2 ], [ 4, %bounds.ok2.i.3 ] ; [#uses = 2, type = i64]
  %.newclass_gc_alloc.i = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #1 ; [#uses = 4]
  %.newclass_gc.i = bitcast %object.Object* %.newclass_gc_alloc.i to %std.utf.UTFException* ; [#uses = 2]
  %vtbl.i = bitcast %object.Object* %.newclass_gc_alloc.i to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl.i, align 8
  %11 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %11, align 8
  %12 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 1 ; [#uses = 1, type = %object.Object*]
  %13 = bitcast %object.Object* %12 to i8*        ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %13, 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)
  %14 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNfAyamQemC6object9ThrowableZCQCmQClQCk(%std.utf.UTFException* nonnull returned %.newclass_gc.i, %object.Throwable* null, i64 1547, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.25, i32 0, i32 0) }, i64 %.lcssa, { i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.27, i32 0, i32 0) }) #4 ; [#uses = 0]
  %15 = load [11 x i8*]*, [11 x i8*]** %vtbl.i, align 8 ; [#uses = 1]
  %"setSequence@vtbl.i" = getelementptr inbounds [11 x i8*], [11 x i8*]* %15, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %16 = bitcast i8** %"setSequence@vtbl.i" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %17 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %16, align 8 ; [#uses = 1]
  %18 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 0 ; [#uses = 1, type = i32*]
  %19 = insertvalue { i64, i32* } undef, i64 %.lcssa, 0 ; [#uses = 1]
  %20 = insertvalue { i64, i32* } %19, i32* %18, 1 ; [#uses = 1]
  %21 = call %std.utf.UTFException* %17(%std.utf.UTFException* nonnull %.newclass_gc.i, { i64, i32* } %20) ; [#uses = 1]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %3)
  ret %std.utf.UTFException* %21

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

bounds.ok2.i.1:                                   ; preds = %bounds.ok.i.1
  %22 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 1 ; [#uses = 1, type = i32*]
  %23 = getelementptr inbounds i8, i8* %2, i64 1  ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = zext i8 %24 to i32                        ; [#uses = 1]
  store i32 %25, i32* %22, align 4
  %26 = icmp ugt i64 %1, 2                        ; [#uses = 1]
  br i1 %26, label %bounds.ok9.i.1, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

bounds.ok9.i.1:                                   ; preds = %bounds.ok2.i.1
  %27 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = and i8 %28, -64                           ; [#uses = 1]
  %30 = icmp eq i8 %29, -128                      ; [#uses = 1]
  br i1 %30, label %bounds.ok.i.2, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

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

bounds.ok2.i.2:                                   ; preds = %bounds.ok.i.2
  %31 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 2 ; [#uses = 1, type = i32*]
  %32 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %34 = zext i8 %33 to i32                        ; [#uses = 1]
  store i32 %34, i32* %31, align 4
  %35 = icmp ugt i64 %1, 3                        ; [#uses = 1]
  br i1 %35, label %bounds.ok9.i.2, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

bounds.ok9.i.2:                                   ; preds = %bounds.ok2.i.2
  %36 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %38 = and i8 %37, -64                           ; [#uses = 1]
  %39 = icmp eq i8 %38, -128                      ; [#uses = 1]
  br i1 %39, label %bounds.ok.i.3, label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit

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

bounds.ok2.i.3:                                   ; preds = %bounds.ok.i.3
  %40 = getelementptr inbounds [4 x i32], [4 x i32]* %sequence.i, i64 0, i64 3 ; [#uses = 1, type = i32*]
  %41 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %42 = load i8, i8* %41, align 1                 ; [#uses = 1]
  %43 = zext i8 %42 to i32                        ; [#uses = 1]
  store i32 %43, i32* %40, align 4
  br label %_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException.exit
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } %msg_arg) local_unnamed_addr #2 {
  %.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) #1 ; [#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.25, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #4 ; [#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) #3
  unreachable
}

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

; [#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 #2 {
  %1 = tail call i32 @fputc_unlocked(i32 %ch_arg, %core.stdc.stdio._IO_FILE* %h_arg) #4 ; [#uses = 1]
  ret i32 %1
}

; [#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 #2 {
  %1 = tail call i32 @fputwc_unlocked(i32 %ch_arg, %core.stdc.stdio._IO_FILE* %h_arg) #4 ; [#uses = 1]
  ret i32 %1
}

; [#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 #1

; [#uses = 14]
; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #7

; [#uses = 12]
; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #7

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

!llvm.ldc.typeinfo._D6source2IO7__ClassZ = !{!0}
!llvm.ldc.classinfo._D6source2IO7__ClassZ = !{!1}
!llvm.ldc.typeinfo._D6Object7__ClassZ = !{!2}
!llvm.ldc.classinfo._D6Object7__ClassZ = !{!3}
!llvm.ldc.typeinfo._D13TypeInfo_AAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D12TypeInfo_Aya6__initZ = !{!5}
!llvm.ldc.typeinfo._D9Exception7__ClassZ = !{!6}
!llvm.ldc.classinfo._D9Exception7__ClassZ = !{!7}
!llvm.ldc.typeinfo._D12TypeInfo_Axa6__initZ = !{!5}
!llvm.ldc.typeinfo._D13TypeInfo_xAya6__initZ = !{!5}
!llvm.ldc.typeinfo._D11TypeInfo_xm6__initZ = !{!8}
!llvm.ldc.typeinfo._D10TypeInfo_m6__initZ = !{!8}
!llvm.ldc.typeinfo._D14TypeInfo_xAAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D14TypeInfo_AxAya6__initZ = !{!4}
!llvm.ldc.typeinfo._D11TypeInfo_xb6__initZ = !{!9}
!llvm.ldc.typeinfo._D10TypeInfo_b6__initZ = !{!9}
!llvm.ldc.typeinfo._D45TypeInfo_S3std5array__T8AppenderTAAyaZQp4Data6__initZ = !{!10}
!llvm.ldc.typeinfo._D11TypeInfo_Ab6__initZ = !{!5}
!llvm.ldc.typeinfo._D3std9exception14ErrnoException7__ClassZ = !{!11}
!llvm.ldc.classinfo._D3std9exception14ErrnoException7__ClassZ = !{!12}
!llvm.ldc.typeinfo._D3std3utf12UTFException7__ClassZ = !{!13}
!llvm.ldc.classinfo._D3std3utf12UTFException7__ClassZ = !{!14}
!llvm.ident = !{!15}

!0 = !{%source.IO* undef}
!1 = !{%source.IO undef, i1 false}
!2 = !{%object.Object* undef}
!3 = !{%object.Object undef, i1 false}
!4 = !{{ i64, { i64, i8* }* } undef}
!5 = !{{ i64, i8* } undef}
!6 = !{%object.Exception* undef}
!7 = !{%object.Exception undef, i1 false}
!8 = !{i64 undef}
!9 = !{i1 undef}
!10 = !{%"std.array.Appender!(string[]).Appender.Data" undef}
!11 = !{%std.exception.ErrnoException* undef}
!12 = !{%std.exception.ErrnoException undef, i1 false}
!13 = !{%std.utf.UTFException* undef}
!14 = !{%std.utf.UTFException undef, i1 false}
!15 = !{!"ldc version 1.28.0"}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.unroll.disable"}
!18 = !{i8 0, i8 2}
!19 = distinct !{!19, !17}
!20 = distinct !{!20, !17}
!21 = distinct !{!21, !17}
!22 = !{!23}
!23 = distinct !{!23, !24}
!24 = distinct !{!24, !"LVerDomain"}
!25 = !{!26}
!26 = distinct !{!26, !24}
!27 = distinct !{!27, !28}
!28 = !{!"llvm.loop.isvectorized", i32 1}
!29 = distinct !{!29, !28}
!30 = distinct !{!30, !17}
!31 = !{!32}
!32 = distinct !{!32, !33, !"_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFNaNbNiNfQDzQEcZSQFsQFrQFk__TQFdVQExa6_61203d3d2062VQExi0TQFwTQGaZQGoFQGiQGlZ6Result: %.sret_arg"}
!33 = distinct !{!33, !"_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFNaNbNiNfQDzQEcZSQFsQFrQFk__TQFdVQExa6_61203d3d2062VQExi0TQFwTQGaZQGoFQGiQGlZ6Result"}
!34 = !{!35}
!35 = distinct !{!35, !36, !"_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFNaNbNiNfQDzQEcZSQFsQFrQFk__TQFdVQExa6_61203d3d2062VQExi0TQFwTQGaZQGoFQGiQGlZ6Result: %.sret_arg"}
!36 = distinct !{!36, !"_D3std9algorithm9iteration__T8splitterVAyaa6_61203d3d2062VEQCf8typecons__T4FlagVQBpa14_6b656570536570617261746f7273ZQBqi0TQDfTQDjZQDxFNaNbNiNfQDzQEcZSQFsQFrQFk__TQFdVQExa6_61203d3d2062VQExi0TQFwTQGaZQGoFQGiQGlZ6Result"}
!37 = !{i64 0, i64 65}
