/+ dub.sdl:
    name "D"
    dependency "dunkelheit" version=">=0.9.0"
+/

import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;

int main() {
    Scanner sc = new Scanner(stdin);
    string s;
    sc.read(s);
    int n = s.length.to!int;
    int i = 0;
    int mid = n/2;
    while (true) {
        if (n/2 + i >= n) break;
        char l = s[(n-1)/2 - i];
        char r = s[n/2 + i];
        if (l != s[mid] || r != s[mid]) break;
        i++;
    }
    writeln(n/2 + i);
    return 0;
}
/* IMPORT /Users/yosupo/Program/dunkelheit/source/dkh/scanner.d */
// module dkh.scanner;

// import dkh.container.stackpayload;

 
class Scanner {
    import std.stdio : File;
    import std.conv : to;
    import std.range : front, popFront, array, ElementType;
    import std.array : split;
    import std.traits : isSomeChar, isStaticArray, isArray; 
    import std.algorithm : map;
    File f;
    this(File f) {
        this.f = f;
    }
    char[512] lineBuf;
    char[] line;
    private bool succW() {
        import std.range.primitives : empty, front, popFront;
        import std.ascii : isWhite;
        while (!line.empty && line.front.isWhite) {
            line.popFront;
        }
        return !line.empty;
    }
    private bool succ() {
        import std.range.primitives : empty, front, popFront;
        import std.ascii : isWhite;
        while (true) {
            while (!line.empty && line.front.isWhite) {
                line.popFront;
            }
            if (!line.empty) break;
            line = lineBuf[];
            f.readln(line);
            if (!line.length) return false;
        }
        return true;
    }

    private bool readSingle(T)(ref T x) {
        import std.algorithm : findSplitBefore;
        import std.string : strip;
        import std.conv : parse;
        if (!succ()) return false;
        static if (isArray!T) {
            alias E = ElementType!T;
            static if (isSomeChar!E) {
                 
                 
                auto r = line.findSplitBefore(" ");
                x = r[0].strip.dup;
                line = r[1];
            } else static if (isStaticArray!T) {
                foreach (i; 0..T.length) {
                    bool f = succW();
                    assert(f);
                    x[i] = line.parse!E;
                }
            } else {
                StackPayload!E buf;
                while (succW()) {
                    buf ~= line.parse!E;
                }
                x = buf.data;
            }
        } else {
            x = line.parse!T;
        }
        return true;
    }
    int read(T, Args...)(ref T x, auto ref Args args) {
        if (!readSingle(x)) return 0;
        static if (args.length == 0) {
            return 1;
        } else {
            return 1 + read(args);
        }
    }
}


 
 

 
/* IMPORT /Users/yosupo/Program/dunkelheit/source/dkh/container/stackpayload.d */
// module dkh.container.stackpayload;

 
struct StackPayload(T, size_t MINCAP = 4) if (MINCAP >= 1) {
    import core.exception : RangeError;

    private T* _data;
    private uint len, cap;

    @property bool empty() const { return len == 0; }
    @property size_t length() const { return len; }
    alias opDollar = length;

     
    inout(T)[] data() inout { return (_data) ? _data[0..len] : null; }
    
    ref inout(T) opIndex(size_t i) inout {
        version(assert) if (len <= i) throw new RangeError();
        return _data[i];
    }  
    ref inout(T) front() inout { return this[0]; }  
    ref inout(T) back() inout { return this[$-1]; }  

    void reserve(size_t newCap) {
        import core.memory : GC;
        import core.stdc.string : memcpy;
        import std.conv : to;
        if (newCap <= cap) return;
        void* newData = GC.malloc(newCap * T.sizeof);
        cap = newCap.to!uint;
        if (len) memcpy(newData, _data, len * T.sizeof);
        _data = cast(T*)(newData);
    }  
    void free() {
        import core.memory : GC;
        GC.free(_data);
    }  
     
    void clear() {
        len = 0;
    }

    void insertBack(T item) {
        import std.algorithm : max;
        if (len == cap) reserve(max(cap * 2, MINCAP));
        _data[len++] = item;
    }  
    alias opOpAssign(string op : "~") = insertBack;  
    void removeBack() {
        assert(!empty, "StackPayload.removeBack: Stack is empty");
        len--;
    }  
}

 
/* IMPORT /Users/yosupo/Program/dunkelheit/source/dkh/foundation.d */
 
// module dkh.foundation;

 
static if (__VERSION__ <= 2070) {
    /*
    Copied by https://github.com/dlang/phobos/blob/master/std/algorithm/iteration.d
    Copyright: Andrei Alexandrescu 2008-.
    License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
    */
    template fold(fun...) if (fun.length >= 1) {
        auto fold(R, S...)(R r, S seed) {
            import std.algorithm : reduce;
            static if (S.length < 2) {
                return reduce!fun(seed, r);
            } else {
                import std.typecons : tuple;
                return reduce!fun(tuple(seed), r);
            }
        }
    }
     
}

/*
This source code generated by dunkelheit and include dunkelheit's source code.
dunkelheit's Copyright: Copyright (c) 2016- Kohei Morita. (https://github.com/yosupo06/dunkelheit)
dunkelheit's License: MIT License(https://github.com/yosupo06/dunkelheit/blob/master/LICENSE.txt)
*/

; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/D/Source_19666/source.d'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/D/Source_19666/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 { i32, i32, 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.Scanner = type { [5 x i8*]*, i8*, %std.stdio.File, [512 x i8], { i64, i8* } }
%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.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.Throwable.TraceInfo = type { [4 x i8*]* }
%object.Throwable = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.TypeInfo_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* }
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%std.conv.ConvOverflowException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%std.exception.ErrnoException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, i32 }>
%object.Exception = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.ModuleInfo = type { i32, i32 }
%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result" = type { %"std.typecons.Tuple!(char[], char[]).Tuple" }
%"std.typecons.Tuple!(char[], char[]).Tuple" = type { { i64, i8* }, { i64, i8* } }
%nest.decodeImpl = type { i8*, i64 }
%std.stdio.File.LockingTextWriter = type { %std.stdio.File, i32, i16, [4 x i8], [6 x i8], i64 }
%nest.decodeImpl.0 = type { i8*, i64 }
%nest.signedToTempString = type { { i64, i8* } }

@_D6source7Scanner7__ClassZ = global %object.TypeInfo_Class { [20 x i8*]* @_D14TypeInfo_Class6__vtblZ, i8* null, { i64, i8* } { i64 568, i8* bitcast (%source.Scanner* @_D6source7Scanner6__initZ to i8*) }, { i64, i8* } { i64 14, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0) }, { i64, i8** } { i64 5, i8** getelementptr inbounds ([5 x i8*], [5 x i8*]* @_D6source7Scanner6__vtblZ, i32 0, i32 0) }, { i64, %object.Interface* } zeroinitializer, %object.TypeInfo_Class* @_D6Object7__ClassZ, i8* bitcast (void (%source.Scanner*)* @_D6source7Scanner11__fieldDtorMFNeZv to i8*), void (%object.Object*)* null, i32 316, [4 x i8] zeroinitializer, i8* null, { i64, %object.OffsetTypeInfo* } zeroinitializer, void (%object.Object*)* null, i8* bitcast ([3 x i64]* @_D6object__T10RTInfoImplVAmA3i568i20i64ZQBcyG3m to i8*) } ; [#uses = 3]
@_D6source7Scanner6__vtblZ = constant [5 x i8*] [i8* bitcast (%object.TypeInfo_Class* @_D6source7Scanner7__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]
@_D6source7Scanner6__initZ = constant %source.Scanner { [5 x i8*]* @_D6source7Scanner6__vtblZ, i8* null, %std.stdio.File zeroinitializer, [512 x i8] c"\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF", { i64, i8* } zeroinitializer }, align 8 ; [#uses = 2]
@.str = private unnamed_addr constant [62 x i8] c"/data/TheStack_IR/OJ_Samples/Collated/D/Source_19666/source.d\00" ; [#uses = 1]
@_D14TypeInfo_Class6__vtblZ = external constant [20 x i8*] ; [#uses = 1]
@.str.1 = private unnamed_addr constant [15 x i8] c"source.Scanner\00" ; [#uses = 1]
@_D6Object7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA3i568i20i64ZQBcyG3m = weak_odr constant [3 x i64] [i64 568, i64 20, i64 64], align 8 ; [#uses = 1]
@.str.2 = private unnamed_addr constant [2 x i8] c" \00" ; [#uses = 1]
@.str.3 = private unnamed_addr constant [56 x i8] c"Attempting to fetch the front of an empty array of char\00" ; [#uses = 1]
@.str.4 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/primitives.d\00" ; [#uses = 1]
@.str.5 = private unnamed_addr constant [45 x i8] c"Attempted to decode past the end of a string\00" ; [#uses = 1]
@.str.6 = private unnamed_addr constant [50 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/utf.d\00" ; [#uses = 1]
@.str.7 = private unnamed_addr constant [58 x i8] c"Attempting to popFront() past the end of an array of char\00" ; [#uses = 1]
@_D3std5range10primitives__T8popFrontTaZQmFNaNbNeMKANgaZ12charWidthTabyAh = weak_odr local_unnamed_addr constant { i64, i8* } { i64 64, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.constarray, i32 0, i32 0) }, align 8 ; [#uses = 0]
@.constarray = internal global [64 x i8] c"\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\04\04\04\04\04\04\04\04\05\05\05\05\06\06\01\01" ; [#uses = 2]
@.str.8 = private unnamed_addr constant [23 x i8] c"Invalid UTF-8 sequence\00" ; [#uses = 1]
@_D3std3utf12UTFException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 6]
@_D3std3utf12UTFException6__vtblZ = external constant [11 x i8*] ; [#uses = 3]
@_D3std3utf12UTFException6__initZ = external local_unnamed_addr constant %std.utf.UTFException, align 8 ; [#uses = 1]
@.str.9 = private unnamed_addr constant [66 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/algorithm/searching.d\00" ; [#uses = 1]
@_D42TypeInfo_xS3std8typecons__T5TupleTAaTQdZQn6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Struct* @_D41TypeInfo_S3std8typecons__T5TupleTAaTQdZQn6__initZ to %object.TypeInfo*) } ; [#uses = 2]
@_D14TypeInfo_Const6__vtblZ = external constant [19 x i8*] ; [#uses = 1]
@_D41TypeInfo_S3std8typecons__T5TupleTAaTQdZQn6__initZ = linkonce_odr global %object.TypeInfo_Struct { [19 x i8*]* @_D15TypeInfo_Struct6__vtblZ, i8* null, { i64, i8* } { i64 32, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.10, i32 0, i32 0) }, { i64, i8* } { i64 32, i8* null }, i64 (i8*)* bitcast (i64 (%"std.typecons.Tuple!(char[], char[]).Tuple"*)* @_D3std8typecons__T5TupleTAaTQdZQn6toHashMxFNaNbNiNfZm to i64 (i8*)*), i1 (i8*, i8*)* bitcast (i1 (%"std.typecons.Tuple!(char[], char[]).Tuple"*, %"std.typecons.Tuple!(char[], char[]).Tuple"*)* @_D3std8typecons__T5TupleTAaTQdZQn11__xopEqualsFKxSQBwQBv__TQBpTQBmTQBqZQCbKxQBbZb to i1 (i8*, i8*)*), i32 (i8*, i8*)* bitcast (i32 (%"std.typecons.Tuple!(char[], char[]).Tuple"*, %"std.typecons.Tuple!(char[], char[]).Tuple"*)* @_D3std8typecons__T5TupleTAaTQdZQn8__xopCmpFKxSQBsQBr__TQBlTQBiTQBmZQBxKxQBbZi to i32 (i8*, i8*)*), { 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__T10RTInfoImplVAmA2i32i10ZQyyG2m to i8*) } ; [#uses = 1]
@_D15TypeInfo_Struct6__vtblZ = external constant [19 x i8*] ; [#uses = 1]
@.str.10 = private unnamed_addr constant [33 x i8] c"S3std8typecons__T5TupleTAaTQdZQn\00" ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i32i10ZQyyG2m = weak_odr constant [2 x i64] [i64 32, i64 10], align 8 ; [#uses = 1]
@.str.11 = private unnamed_addr constant [53 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/string.d\00" ; [#uses = 1]
@_D12TypeInfo_Axa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D11TypeInfo_Aa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D3std4conv21ConvOverflowException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D3std4conv21ConvOverflowException6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D3std4conv21ConvOverflowException6__initZ = external local_unnamed_addr constant %std.conv.ConvOverflowException, align 8 ; [#uses = 1]
@.str.12 = private unnamed_addr constant [29 x i8] c"Conversion positive overflow\00" ; [#uses = 1]
@.str.13 = private unnamed_addr constant [51 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/conv.d\00" ; [#uses = 1]
@.str.14 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/stdio.d\00" ; [#uses = 1]
@.str.15 = private unnamed_addr constant [41 x i8] c"Encoding an invalid code point in UTF-32\00" ; [#uses = 1]
@.str.16 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/core/internal/string.d\00" ; [#uses = 1]
@_D3std9exception14ErrnoException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D3std9exception14ErrnoException6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D3std9exception14ErrnoException6__initZ = external local_unnamed_addr constant %std.exception.ErrnoException, align 8 ; [#uses = 1]
@.str.17 = private unnamed_addr constant [19 x i8] c"Enforcement failed\00" ; [#uses = 1]
@_D12TypeInfo_Aya6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.18 = private unnamed_addr constant [39 x i8] c"Attempt to read from an unopened file.\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]
@_D6source12__ModuleInfoZ = global %0 { i32 -2147481596, i32 0, i64 1, [1 x %object.TypeInfo_Class*] [%object.TypeInfo_Class* @_D6source7Scanner7__ClassZ], [7 x i8] c"source\00" } ; [#uses = 1]
@_D6source11__moduleRefZ = linkonce_odr hidden global %object.ModuleInfo* bitcast (%0* @_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 {
  %__copytmp118 = alloca %std.stdio.File, align 8 ; [#uses = 3, size/byte = 24]
  %s = alloca { i64, i8* }, align 8               ; [#uses = 4, size/byte = 16]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D6source7Scanner7__ClassZ) #1 ; [#uses = 4]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %source.Scanner* ; [#uses = 2]
  %vtbl = getelementptr %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 0 ; [#uses = 1, type = [5 x i8*]**]
  store [5 x i8*]* @_D6source7Scanner6__vtblZ, [5 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(552) %3, i8* nonnull align 8 dereferenceable(552) bitcast (%std.stdio.File* getelementptr inbounds (%source.Scanner, %source.Scanner* @_D6source7Scanner6__initZ, i64 0, i32 2) to i8*), i64 552, i1 false)
  %4 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #4 ; [#uses = 1]
  %5 = bitcast %std.stdio.File* %__copytmp118 to i8* ; [#uses = 1]
  %6 = bitcast %std.stdio.File* %4 to i8*         ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(24) %5, i8* nonnull align 1 dereferenceable(24) %6, i64 24, i1 false)
  call void @_D3std5stdio4File10__postblitMFNbNfZv(%std.stdio.File* nonnull %__copytmp118) #4
  %7 = call %source.Scanner* @_D6source7Scanner6__ctorMFS3std5stdio4FileZCQBqQBm(%source.Scanner* nonnull returned %.newclass_gc, %std.stdio.File* noalias nocapture nonnull align 8 %__copytmp118) #4 ; [#uses = 0]
  %.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %s, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %s, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %8 = bitcast { i64, i8* }* %s to i8*            ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %8, i8 0, i64 16, i1 false)
  %9 = call zeroext i1 @_D6source7Scanner__T10readSingleTAyaZQrMFKQjZb(%source.Scanner* nonnull %.newclass_gc, { i64, i8* }* nonnull dereferenceable(16) %s) #4 ; [#uses = 0]
  %.len = load i64, i64* %.fca.0.gep, align 8     ; [#uses = 1]
  %10 = call i32 @_D3std4conv__T6toImplTiTmZQmFNaNfmZi(i64 %.len) #4 ; [#uses = 4]
  %11 = sdiv i32 %10, 2                           ; [#uses = 5]
  %12 = add nsw i32 %10, -1                       ; [#uses = 1]
  %13 = sdiv i32 %12, 2                           ; [#uses = 1]
  %.len1 = load i64, i64* %.fca.0.gep, align 8    ; [#uses = 6]
  %.ptr = load i8*, i8** %.fca.1.gep, align 8     ; [#uses = 3]
  %14 = sext i32 %11 to i64                       ; [#uses = 3]
  %bounds.cmp8 = icmp ugt i64 %.len1, %14         ; [#uses = 1]
  %15 = getelementptr inbounds i8, i8* %.ptr, i64 %14 ; [#uses = 1, type = i8*]
  %16 = icmp sgt i32 %10, %11                     ; [#uses = 1]
  %smax = select i1 %16, i32 %10, i32 %11         ; [#uses = 2]
  %17 = sub i32 %smax, %11                        ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %bounds.ok9, %0
  %i.0 = phi i32 [ 0, %0 ], [ %27, %bounds.ok9 ]  ; [#uses = 4, type = i32]
  %18 = add i32 %i.0, %11                         ; [#uses = 2]
  %exitcond.not = icmp eq i32 %i.0, %17           ; [#uses = 1]
  br i1 %exitcond.not, label %endfor, label %endif

endif:                                            ; preds = %forcond
  %19 = sub i32 %13, %i.0                         ; [#uses = 1]
  %20 = sext i32 %19 to i64                       ; [#uses = 3]
  %bounds.cmp = icmp ugt i64 %.len1, %20          ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %endif
  %21 = sext i32 %18 to i64                       ; [#uses = 3]
  %bounds.cmp3 = icmp ugt i64 %.len1, %21         ; [#uses = 1]
  br i1 %bounds.cmp3, label %bounds.ok4, label %bounds.fail5

bounds.ok4:                                       ; preds = %bounds.ok
  br i1 %bounds.cmp8, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %bounds.ok4
  %22 = getelementptr inbounds i8, i8* %.ptr, i64 %21 ; [#uses = 1, type = i8*]
  %23 = load i8, i8* %22, align 1                 ; [#uses = 1]
  %24 = getelementptr inbounds i8, i8* %.ptr, i64 %20 ; [#uses = 1, type = i8*]
  %25 = load i8, i8* %24, align 1                 ; [#uses = 1]
  %26 = load i8, i8* %15, align 1                 ; [#uses = 2]
  %.not37 = icmp eq i8 %25, %26                   ; [#uses = 1]
  %.not38 = icmp eq i8 %23, %26                   ; [#uses = 1]
  %or.cond = and i1 %.not37, %.not38              ; [#uses = 1]
  %27 = add nuw i32 %i.0, 1                       ; [#uses = 1]
  br i1 %or.cond, label %forcond, label %endfor

bounds.fail10:                                    ; preds = %bounds.ok4
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 20, i64 %14, i64 %.len1) #5
  unreachable

bounds.fail5:                                     ; preds = %bounds.ok
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 19, i64 %21, i64 %.len1) #5
  unreachable

bounds.fail:                                      ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 18, i64 %20, i64 %.len1) #5
  unreachable

endfor:                                           ; preds = %forcond, %bounds.ok9
  %.lcssa54 = phi i32 [ %18, %bounds.ok9 ], [ %smax, %forcond ] ; [#uses = 1, type = i32]
  call void @_D3std5stdio__T7writelnTiZQlFNfiZv(i32 %.lcssa54) #4
  ret i32 0
}

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

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

; [#uses = 1]
; Function Attrs: uwtable
define nonnull %source.Scanner* @_D6source7Scanner6__ctorMFS3std5stdio4FileZCQBqQBm(%source.Scanner* nonnull returned %.this_arg, %std.stdio.File* noalias nocapture align 8 %f) local_unnamed_addr #3 {
finally:
  %0 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 2 ; [#uses = 2, type = %std.stdio.File*]
  %1 = bitcast %std.stdio.File* %0 to i8*         ; [#uses = 1]
  %2 = bitcast %std.stdio.File* %f to i8*         ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(24) %1, i8* nonnull align 8 dereferenceable(24) %2, i64 24, i1 false)
  tail call void @_D3std5stdio4File10__postblitMFNbNfZv(%std.stdio.File* nonnull %0) #4
  tail call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %f) #4
  ret %source.Scanner* %.this_arg
}

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D6source7Scanner__T4readTAyaZQkMFKQjZi(%source.Scanner* nonnull %.this_arg, { i64, i8* }* dereferenceable(16) %x) local_unnamed_addr #3 {
if:
  %0 = tail call zeroext i1 @_D6source7Scanner__T10readSingleTAyaZQrMFKQjZb(%source.Scanner* nonnull %.this_arg, { i64, i8* }* nonnull dereferenceable(16) %x) #4 ; [#uses = 1]
  %spec.select = zext i1 %0 to i32                ; [#uses = 1]
  ret i32 %spec.select
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std4conv__T2toTiZ__TQjTmZQoFNaNfmZi(i64 %_param_0_arg) local_unnamed_addr #3 {
  %1 = tail call i32 @_D3std4conv__T6toImplTiTmZQmFNaNfmZi(i64 %_param_0_arg) #4 ; [#uses = 1]
  ret i32 %1
}

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define zeroext i1 @_D6source7Scanner5succWMFZb(%source.Scanner* nonnull %.this_arg) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4 ; [#uses = 2, type = { i64, i8* }*]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %1, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %3 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4, i32 1 ; [#uses = 1, type = i8**]
  br label %forcond

forcond:                                          ; preds = %forbody, %0
  %.len.i = load i64, i64* %2, align 8            ; [#uses = 2]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br i1 %.not.i, label %endfor, label %andand

andand:                                           ; preds = %forcond
  %.ptr = load i8*, i8** %3, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %.ptr, 1  ; [#uses = 1]
  %6 = tail call i32 @_D3std5range10primitives__T5frontTaZQjFNaNdNfMAxaZw({ i64, i8* } %5) #4 ; [#uses = 1]
  %7 = tail call zeroext i1 @_D3std5ascii7isWhiteFNaNbNiNfwZb(i32 %6) #4 ; [#uses = 1]
  br i1 %7, label %forbody, label %andand.endfor_crit_edge

andand.endfor_crit_edge:                          ; preds = %andand
  %.len.i3.pre = load i64, i64* %2, align 8       ; [#uses = 1]
  %phi.cmp = icmp ne i64 %.len.i3.pre, 0          ; [#uses = 1]
  br label %endfor

forbody:                                          ; preds = %andand
  tail call void @_D3std5range10primitives__T8popFrontTaZQmFNaNbNiNeMKANgaZv({ i64, i8* }* nonnull dereferenceable(16) %1) #4
  br label %forcond

endfor:                                           ; preds = %forcond, %andand.endfor_crit_edge
  %.len.i3 = phi i1 [ %phi.cmp, %andand.endfor_crit_edge ], [ false, %forcond ] ; [#uses = 1, type = i1]
  ret i1 %.len.i3
}

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

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

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

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

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

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

condfalse:                                        ; preds = %bounds.ok
  %5 = zext i8 %3 to i64                          ; [#uses = 1]
  %6 = add nuw nsw i64 %5, 4294967104             ; [#uses = 1]
  %7 = and i64 %6, 4294967295                     ; [#uses = 1]
  %8 = getelementptr inbounds [64 x i8], [64 x i8]* @.constarray, i64 0, i64 %7 ; [#uses = 1, type = i8*]
  %9 = load i8, i8* %8, align 1                   ; [#uses = 1]
  %10 = zext i8 %9 to i32                         ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %bounds.ok, %condfalse
  %condtmp.0.sroa.speculated = phi i32 [ %10, %condfalse ], [ 1, %bounds.ok ] ; [#uses = 2, type = i32]
  %11 = zext i32 %condtmp.0.sroa.speculated to i64 ; [#uses = 1]
  %12 = icmp ugt i64 %.len, %11                   ; [#uses = 1]
  %13 = trunc i64 %.len to i32                    ; [#uses = 1]
  %spec.select = select i1 %12, i32 %condtmp.0.sroa.speculated, i32 %13 ; [#uses = 1]
  %14 = sext i32 %spec.select to i64              ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len, %14    ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail8, label %bounds.ok7

bounds.ok7:                                       ; preds = %condend
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %14 ; [#uses = 1, type = i8*]
  %15 = sub i64 %.len, %14                        ; [#uses = 1]
  store i64 %15, i64* %1, align 8
  store i8* %lowerbound, i8** %2, align 8
  ret void

bounds.fail8:                                     ; preds = %condend
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.4, i32 0, i32 0) }, i32 2313, i64 %14, i64 %.len, i64 0) #5
  unreachable

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

; [#uses = 1]
; Function Attrs: uwtable
define zeroext i1 @_D6source7Scanner4succMFZb(%source.Scanner* nonnull %.this_arg) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4 ; [#uses = 3, type = { i64, i8* }*]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %1, i64 0, i32 0 ; [#uses = 4, type = i64*]
  %3 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4, i32 1 ; [#uses = 2, type = i8**]
  %4 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 3, i64 0 ; [#uses = 1, type = i8*]
  %5 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 2 ; [#uses = 1, type = %std.stdio.File*]
  br label %forcond1

forcond1:                                         ; preds = %forcond1.backedge, %0
  %.len.i = load i64, i64* %2, align 8            ; [#uses = 2]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  br i1 %.not.i, label %endif, label %andand

andand:                                           ; preds = %forcond1
  %.ptr = load i8*, i8** %3, align 8              ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.ptr, 1  ; [#uses = 1]
  %8 = tail call i32 @_D3std5range10primitives__T5frontTaZQjFNaNdNfMAxaZw({ i64, i8* } %7) #4 ; [#uses = 1]
  %9 = tail call zeroext i1 @_D3std5ascii7isWhiteFNaNbNiNfwZb(i32 %8) #4 ; [#uses = 1]
  br i1 %9, label %forbody2, label %endfor4

forbody2:                                         ; preds = %andand
  tail call void @_D3std5range10primitives__T8popFrontTaZQmFNaNbNiNeMKANgaZv({ i64, i8* }* nonnull dereferenceable(16) %1) #4
  br label %forcond1.backedge

forcond1.backedge:                                ; preds = %forbody2, %endif
  br label %forcond1

endfor4:                                          ; preds = %andand
  %.len.i16.pr = load i64, i64* %2, align 8       ; [#uses = 1]
  %.not.i17 = icmp eq i64 %.len.i16.pr, 0         ; [#uses = 1]
  br i1 %.not.i17, label %endif, label %if6

endif:                                            ; preds = %forcond1, %endfor4
  store i64 512, i64* %2, align 8
  store i8* %4, i8** %3, align 8
  %10 = tail call i64 @_D3std5stdio4File__T6readlnTaZQkMFKAawZm(%std.stdio.File* nonnull %5, i32 10, { i64, i8* }* nonnull dereferenceable(16) %1) #4 ; [#uses = 0]
  %.len5 = load i64, i64* %2, align 8             ; [#uses = 1]
  %.not = icmp eq i64 %.len5, 0                   ; [#uses = 1]
  br i1 %.not, label %if6, label %forcond1.backedge

if6:                                              ; preds = %endfor4, %endif
  %merge = phi i1 [ false, %endif ], [ true, %endfor4 ] ; [#uses = 1, type = i1]
  ret i1 %merge
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5stdio4File__T6readlnTaZQkMFKAawZm(%std.stdio.File* nonnull %.this_arg, i32 %terminator_arg, { i64, i8* }* dereferenceable(16) %buf) local_unnamed_addr #3 {
  %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.18, i32 0, i32 0) }, i64 2083, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.14, i32 0, i32 0) }) #12
  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 = 1]
; Function Attrs: uwtable
define void @_D6source7Scanner11__fieldDtorMFNeZv(%source.Scanner* nonnull %.this_arg) #3 {
  %1 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 2 ; [#uses = 1, type = %std.stdio.File*]
  tail call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %1) #4
  ret void
}

; [#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 = 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 #3 {
  %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
define weak_odr zeroext i1 @_D6source7Scanner__T10readSingleTAyaZQrMFKQjZb(%source.Scanner* nonnull %.this_arg, { i64, i8* }* dereferenceable(16) %x) local_unnamed_addr #3 {
  %r = alloca %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", align 8 ; [#uses = 5, size/byte = 32]
  %1 = tail call zeroext i1 @_D6source7Scanner4succMFZb(%source.Scanner* nonnull %.this_arg) #3 ; [#uses = 1]
  br i1 %1, label %endif, label %if

if:                                               ; preds = %0
  ret i1 false

endif:                                            ; preds = %0
  %.elt = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4, i32 0 ; [#uses = 2, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %2 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt6 = getelementptr inbounds %source.Scanner, %source.Scanner* %.this_arg, i64 0, i32 4, i32 1 ; [#uses = 2, type = i8**]
  %.unpack7 = load i8*, i8** %.elt6, align 8      ; [#uses = 1]
  %3 = insertvalue { i64, i8* } %2, i8* %.unpack7, 1 ; [#uses = 1]
  call void @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFNaNbNiNfQsQBnZSQDlQDkQDd__TQCwVQCia6_61203d3d2062TQCiTQDfZQEbFQCuQDqZ__T6ResultTQDmTQDqZQq(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* noalias nonnull sret align 8 %r, { i64, i8* } { i64 1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i32 0, i32 0) }, { i64, i8* } %3) #4
  %.fca.0.gep = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %r, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.fca.0.load = load i64, i64* %.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.gep = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %r, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.fca.1.load = load i8*, i8** %.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  %4 = call { i64, i8* } @_D3std6string__T5stripTAaZQkFNaNbNiNfQoZQr({ i64, i8* } %.fca.1.insert) #4 ; [#uses = 1]
  %5 = call { i64, i8* } @_D6object__T4_dupTxaTaZQlFNaNbNeMAxaZAa({ i64, i8* } %4) #4 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %5, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %5, 0         ; [#uses = 1]
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %x, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %6, align 8
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %x, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr, i8** %7, align 8
  %8 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %r, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %9 = bitcast i8** %8 to i64*                    ; [#uses = 1]
  %.ptr18 = load i64, i64* %9, align 8            ; [#uses = 1]
  %10 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %r, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2 = load i64, i64* %10, align 8            ; [#uses = 1]
  store i64 %.len2, i64* %.elt, align 8
  %11 = bitcast i8** %.elt6 to i64*               ; [#uses = 1]
  store i64 %.ptr18, i64* %11, align 8
  ret i1 true
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFNaNbNiNfQsQBnZSQDlQDkQDd__TQCwVQCia6_61203d3d2062TQCiTQDfZQEbFQCuQDqZ__T6ResultTQDmTQDqZQq(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* noalias sret align 8 %.sret_arg, { i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #3 {
  %haystack_arg.fca.0.extract = extractvalue { i64, i8* } %haystack_arg, 0 ; [#uses = 3]
  %haystack_arg.fca.1.extract = extractvalue { i64, i8* } %haystack_arg, 1 ; [#uses = 2]
  %1 = tail call { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) #4 ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %1, 0         ; [#uses = 3]
  %2 = sub i64 %haystack_arg.fca.0.extract, %.len ; [#uses = 3]
  %bounds.cmp.up.not = icmp ult i64 %haystack_arg.fca.0.extract, %.len ; [#uses = 1]
  %3 = bitcast %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.sret_arg to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) %3, i8 0, i64 32, i1 false)
  br i1 %bounds.cmp.up.not, label %bounds.fail, label %bounds.ok6

bounds.ok6:                                       ; preds = %0
  %.repack = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.sret_arg, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.repack21 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.sret_arg, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.repack20 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.sret_arg, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.repack19 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.sret_arg, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %lowerbound11 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %2 ; [#uses = 1, type = i8*]
  store i64 %2, i64* %.repack, align 8
  store i8* %haystack_arg.fca.1.extract, i8** %.repack19, align 8
  store i64 %.len, i64* %.repack20, align 8
  store i8* %lowerbound11, i8** %.repack21, align 8
  ret void

bounds.fail:                                      ; preds = %0
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 65, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.9, i32 0, i32 0) }, i32 3007, i64 0, i64 %2, i64 %haystack_arg.fca.0.extract) #5
  unreachable
}

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std6string__T5stripTAaZQkFNaNbNiNfQoZQr({ i64, i8* } %str_arg) local_unnamed_addr #3 {
  %1 = tail call { i64, i8* } @_D3std6string__T9stripLeftTAaZQoFNaNbNiNfQoZQr({ i64, i8* } %str_arg) #4 ; [#uses = 1]
  %2 = tail call { i64, i8* } @_D3std6string__T10stripRightTAaZQqFNaNbNiNfQoZQr({ i64, i8* } %1) #4 ; [#uses = 1]
  ret { i64, i8* } %2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

endif41:                                          ; preds = %endif38
  ret i32 %74

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

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

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

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

_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit: ; preds = %condend
  %1 = zext i32 %_param_1_arg to i64              ; [#uses = 1]
  %2 = icmp ult i64 %1, %_param_0_arg             ; [#uses = 1]
  %3 = trunc i64 %_param_0_arg to i32             ; [#uses = 1]
  br i1 %2, label %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit.thread, label %4

_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit.thread: ; preds = %condend, %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit
  br label %4

4:                                                ; preds = %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit, %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit.thread
  %5 = phi i32 [ %_param_1_arg, %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit.thread ], [ %3, %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb.exit ] ; [#uses = 1, type = i32]
  ret i32 %5
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTyiTmZQBcFNaNbNiNfKyiKmZb(i64* dereferenceable(8) %b, i32* dereferenceable(4) %a) local_unnamed_addr #3 {
  %1 = load i32, i32* %a, align 4                 ; [#uses = 2]
  %2 = icmp slt i32 %1, 0                         ; [#uses = 1]
  br i1 %2, label %ororend, label %oror

oror:                                             ; preds = %0
  %3 = load i64, i64* %b, align 8                 ; [#uses = 1]
  %4 = zext i32 %1 to i64                         ; [#uses = 1]
  %5 = icmp ugt i64 %3, %4                        ; [#uses = 1]
  br label %ororend

ororend:                                          ; preds = %oror, %0
  %ororval = phi i1 [ true, %0 ], [ %5, %oror ]   ; [#uses = 1, type = i1]
  ret i1 %ororval
}

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ__T9exceptionTQBcZQpFNaNbNfQBpQDsZCQFvQFu12UTFException({ i64, i8* } %msg_arg, { i64, i8* } %str_arg) local_unnamed_addr #3 {
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.6, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #5
  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.6, 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_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ11outOfBoundsMFNaNbZCQFhQFg12UTFException(i8* nonnull %.nest_arg) local_unnamed_addr #3 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFKQjKmZ__T9exceptionTQBcZQpFNaNbNfQBpQDsZCQFvQFu12UTFException({ i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.5, i32 0, i32 0) }, { i64, i8* } %5) #4 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

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

; [#uses = 2]
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 { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAaTQwZQBfFNaNbNiNfQsMQBoZQz({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #3 {
  %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.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFQkQBfZ__T6ResultTQBbTQBfZQq6__ctorMFNaNbNcNiNfQCeQChZSQEyQExQEq__TQEjVQDva6_61203d3d2062TQDvTQEsZQFoFQEhQFdZ__TQDyTQEvTQEzZQEk(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* nonnull returned %.this_arg, { i64, i8* } %post_arg, { i64, i8* } %pre_arg) local_unnamed_addr #3 {
  %_param_0_arg.fca.0.extract.i = extractvalue { i64, i8* } %pre_arg, 0 ; [#uses = 1]
  %_param_0_arg.fca.1.extract.i = extractvalue { i64, i8* } %pre_arg, 1 ; [#uses = 1]
  %_param_1_arg.fca.0.extract.i = extractvalue { i64, i8* } %post_arg, 0 ; [#uses = 1]
  %_param_1_arg.fca.1.extract.i = extractvalue { i64, i8* } %post_arg, 1 ; [#uses = 1]
  %1 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %_param_0_arg.fca.0.extract.i, i64* %1, align 8
  %2 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %_param_0_arg.fca.1.extract.i, i8** %2, align 8
  %3 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %_param_1_arg.fca.0.extract.i, i64* %3, align 8
  %4 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  store i8* %_param_1_arg.fca.1.extract.i, i8** %4, align 8
  ret %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg
}

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAhTQdZQBfFNaNbNiNfQsMQvZQy({ i64, i8* } %needle_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #3 {
  %haystack_arg.fca.0.extract = extractvalue { i64, i8* } %haystack_arg, 0 ; [#uses = 12]
  %haystack_arg.fca.1.extract = extractvalue { i64, i8* } %haystack_arg, 1 ; [#uses = 5]
  %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 = 5]
  %4 = getelementptr inbounds i8, i8* %needle_arg.fca.1.extract, i64 %3 ; [#uses = 1, type = i8*]
  %5 = load i8, i8* %4, align 1                   ; [#uses = 2]
  br label %forcond.outer

forcond.outer:                                    ; preds = %endif48, %bounds.ok9
  %skip.0.ph = phi i64 [ %skip.2, %endif48 ], [ 0, %bounds.ok9 ] ; [#uses = 2, type = i64]
  %j.0.ph = phi i64 [ %29, %endif48 ], [ %3, %bounds.ok9 ] ; [#uses = 1, type = i64]
  br label %forcond

forcond:                                          ; preds = %forcond.outer, %if18
  %j.0 = phi i64 [ %10, %if18 ], [ %j.0.ph, %forcond.outer ] ; [#uses = 5, type = i64]
  %6 = icmp ult i64 %j.0, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %6, label %bounds.ok15, label %bounds.ok65

bounds.ok15:                                      ; preds = %forcond
  %7 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %j.0 ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %9 = icmp eq i8 %8, %5                          ; [#uses = 1]
  br i1 %9, label %endif19, label %if18

if18:                                             ; preds = %bounds.ok15
  %10 = add nuw i64 %j.0, 1                       ; [#uses = 1]
  br label %forcond

endif19:                                          ; preds = %bounds.ok15
  %11 = sub i64 %j.0, %3                          ; [#uses = 7]
  br label %forcond20

forcond20:                                        ; preds = %bounds.ok42, %endif19
  %i.0 = phi i64 [ 0, %endif19 ], [ %22, %bounds.ok42 ] ; [#uses = 5, type = i64]
  %12 = icmp eq i64 %i.0, %3                      ; [#uses = 1]
  br i1 %12, label %if24, label %endif25

if24:                                             ; preds = %forcond20
  %bounds.cmp.lo31.not = icmp ult i64 %haystack_arg.fca.0.extract, %11 ; [#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 %11 ; [#uses = 1, type = i8*]
  %13 = sub i64 %haystack_arg.fca.0.extract, %11  ; [#uses = 1]
  %14 = insertvalue { i64, i8* } undef, i64 %13, 0 ; [#uses = 1]
  %15 = insertvalue { i64, i8* } %14, i8* %lowerbound33, 1 ; [#uses = 1]
  ret { i64, i8* } %15

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

endif25:                                          ; preds = %forcond20
  %16 = add nuw i64 %i.0, %11                     ; [#uses = 2]
  %bounds.cmp36 = icmp ult i64 %16, %haystack_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

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

bounds.ok42:                                      ; preds = %bounds.ok37
  %17 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %16 ; [#uses = 1, type = i8*]
  %18 = getelementptr inbounds i8, i8* %needle_arg.fca.1.extract, i64 %i.0 ; [#uses = 1, type = i8*]
  %19 = load i8, i8* %17, align 1                 ; [#uses = 1]
  %20 = load i8, i8* %18, align 1                 ; [#uses = 1]
  %21 = icmp eq i8 %19, %20                       ; [#uses = 1]
  %22 = add nuw i64 %i.0, 1                       ; [#uses = 1]
  br i1 %21, label %forcond20, label %endfor23

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

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

endfor23:                                         ; preds = %bounds.ok42
  %24 = icmp eq i64 %skip.0.ph, 0                 ; [#uses = 1]
  br i1 %24, label %forcond49, label %endif48

forcond49:                                        ; preds = %endfor23, %forbody50
  %skip.1 = phi i64 [ %28, %forbody50 ], [ 1, %endfor23 ] ; [#uses = 4, type = i64]
  %exitcond142.not = icmp eq i64 %skip.1, %needle_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond142.not, label %endif48, label %andand

andand:                                           ; preds = %forcond49
  %25 = sub i64 %3, %skip.1                       ; [#uses = 3]
  %bounds.cmp54 = icmp ult i64 %25, %needle_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp54, label %bounds.ok60, label %bounds.fail56

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

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

forbody50:                                        ; preds = %bounds.ok60
  %28 = add i64 %skip.1, 1                        ; [#uses = 1]
  br label %forcond49

endif48:                                          ; preds = %bounds.ok60, %forcond49, %endfor23
  %skip.2 = phi i64 [ %skip.0.ph, %endfor23 ], [ %skip.1, %bounds.ok60 ], [ %needle_arg.fca.0.extract, %forcond49 ] ; [#uses = 2, type = i64]
  %29 = add i64 %skip.2, %j.0                     ; [#uses = 1]
  br label %forcond.outer

bounds.ok65:                                      ; preds = %forcond
  %lowerbound71 = getelementptr inbounds i8, i8* %haystack_arg.fca.1.extract, i64 %haystack_arg.fca.0.extract ; [#uses = 1, type = i8*]
  %30 = insertvalue { i64, i8* } { i64 0, i8* undef }, i8* %lowerbound71, 1 ; [#uses = 1]
  ret { i64, i8* } %30
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9searching__T4findVAyaa6_61203d3d2062TAaTQwZQBfFQkMQBgZ__T5forceTAhTQBeZQoFNaNbNiNeNgAaZQx({ i64, i8* } %r_arg) local_unnamed_addr #3 {
  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 #3 {
  %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 #3 {
  %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 = 4]
; Function Attrs: argmemonly nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #6

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFQkQBfZ__T6ResultTQBbTQBfZQq8opAssignMFNaNbNiNfSQEr8typecons__T5TupleTQDbTQDfZQpZv(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* nonnull %.this_arg, %"std.typecons.Tuple!(char[], char[]).Tuple"* byval align 8 %rhs) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %2 = bitcast i8** %1 to i64*                    ; [#uses = 1]
  %.ptr7.i = load i64, i64* %2, align 8           ; [#uses = 1]
  %3 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %3, align 8            ; [#uses = 1]
  %4 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len.i, i64* %4, align 8
  %5 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 1]
  store i64 %.ptr7.i, i64* %6, align 8
  %7 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %8 = bitcast i8** %7 to i64*                    ; [#uses = 1]
  %.ptr18.i = load i64, i64* %8, align 8          ; [#uses = 1]
  %9 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2.i = load i64, i64* %9, align 8           ; [#uses = 1]
  %10 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len2.i, i64* %10, align 8
  %11 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %12 = bitcast i8** %11 to i64*                  ; [#uses = 1]
  store i64 %.ptr18.i, i64* %12, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.typecons.Tuple!(char[], char[]).Tuple"* @_D3std8typecons__T5TupleTAaTQdZQn__T8opAssignTSQBtQBs__TQBmTQBjTQBnZQByZQBkMFNaNbNcNiNfKQBqZQBu(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(char[], char[]).Tuple"* dereferenceable(32) %rhs) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %2 = bitcast i8** %1 to i64*                    ; [#uses = 1]
  %.ptr7 = load i64, i64* %2, align 8             ; [#uses = 1]
  %3 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  %4 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %4, align 8
  %5 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 1]
  store i64 %.ptr7, i64* %6, align 8
  %7 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %8 = bitcast i8** %7 to i64*                    ; [#uses = 1]
  %.ptr18 = load i64, i64* %8, align 8            ; [#uses = 1]
  %9 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2 = load i64, i64* %9, align 8             ; [#uses = 1]
  %10 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len2, i64* %10, align 8
  %11 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %12 = bitcast i8** %11 to i64*                  ; [#uses = 1]
  store i64 %.ptr18, i64* %12, align 8
  ret %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFQkQBfZ__T6ResultTQBbTQBfZQq8opAssignMFNaNbNcNiNjNfSQEvQEuQEn__TQEgVQDsa6_61203d3d2062TQDsTQEpZQFlFQEeQFaZ__TQDvTQEsTQEwZQEhZQCw(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* nonnull %.this_arg, %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* byval align 8 %p) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %2 = bitcast i8** %1 to i64*                    ; [#uses = 1]
  %.ptr7.i = load i64, i64* %2, align 8           ; [#uses = 1]
  %3 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %3, align 8            ; [#uses = 1]
  %4 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len.i, i64* %4, align 8
  %5 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 1]
  store i64 %.ptr7.i, i64* %6, align 8
  %7 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %8 = bitcast i8** %7 to i64*                    ; [#uses = 1]
  %.ptr18.i = load i64, i64* %8, align 8          ; [#uses = 1]
  %9 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.len2.i = load i64, i64* %9, align 8           ; [#uses = 1]
  %10 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len2.i, i64* %10, align 8
  %11 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg, i64 0, i32 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %12 = bitcast i8** %11 to i64*                  ; [#uses = 1]
  store i64 %.ptr18.i, i64* %12, align 8
  ret %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFQkQBfZ__T6ResultTQBbTQBfZQq11__xopEqualsFKxSQEoQEnQEg__TQDzVQDla6_61203d3d2062TQDlTQEiZQFeFQDxQEtZ__TQDoTQElTQEpZQEaKxQCxZb(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* dereferenceable(32) %q, %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* dereferenceable(32) %p) local_unnamed_addr #3 {
  %1 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p, i64 0, i32 0 ; [#uses = 1, type = %"std.typecons.Tuple!(char[], char[]).Tuple"*]
  %2 = getelementptr inbounds %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result", %"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %q, i64 0, i32 0 ; [#uses = 1, type = %"std.typecons.Tuple!(char[], char[]).Tuple"*]
  %3 = tail call zeroext i1 @_D3std8typecons__T5TupleTAaTQdZQn__T8opEqualsTxSQBuQBt__TQBnTQBkTQBoZQBzZQBlMxFNaNbNiNfxQBpZb(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %1, %"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull byval align 8 %2) #4 ; [#uses = 1]
  ret i1 %3
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTAaTQdZQn__T8opEqualsTxSQBuQBt__TQBnTQBkTQBoZQBzZQBlMxFNaNbNiNfxQBpZb(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(char[], char[]).Tuple"* byval align 8 %rhs) local_unnamed_addr #3 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, 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 %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, 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 %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, 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 %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, 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]
  br i1 %5, label %andand, label %andandend

andand:                                           ; preds = %0
  %.elt7 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack8 = load i64, i64* %.elt7, align 8      ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack8, 0 ; [#uses = 1]
  %.elt9 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack10 = load i8*, i8** %.elt9, align 8     ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack10, 1 ; [#uses = 1]
  %.elt11 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack12 = load i64, i64* %.elt11, align 8    ; [#uses = 1]
  %8 = insertvalue { i64, i8* } undef, i64 %.unpack12, 0 ; [#uses = 1]
  %.elt13 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack14 = load i8*, i8** %.elt13, align 8    ; [#uses = 1]
  %9 = insertvalue { i64, i8* } %8, i8* %.unpack14, 1 ; [#uses = 1]
  %10 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %9, { i64, i8* } %7) #4 ; [#uses = 1]
  br label %andandend

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm9searching__T15findSplitBeforeVAyaa6_61203d3d2062TAaTQwZQBrFQkQBfZ__T6ResultTQBbTQBfZQq9__xtoHashFNbNeKxSQEpQEoQEh__TQEaVQDma6_61203d3d2062TQDmTQEjZQFfFQDyQEuZ__TQDpTQEmTQEqZQEbZm(%"std.algorithm.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* dereferenceable(32) %p) local_unnamed_addr #3 {
unrolledstmt:
  %0 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D42TypeInfo_xS3std8typecons__T5TupleTAaTQdZQn6__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.searching.findSplitBefore!(\22a == b\22, char[], string).findSplitBefore.Result!(char[], char[]).Result"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D42TypeInfo_xS3std8typecons__T5TupleTAaTQdZQn6__initZ, i8* nonnull %3) ; [#uses = 1]
  ret i64 %4
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std8typecons__T5TupleTAaTQdZQn6toHashMxFNaNbNiNfZm(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %.this_arg) #3 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, 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]
  %.elt6 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack7 = load i8*, i8** %.elt6, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack7, 1 ; [#uses = 1]
  %3 = tail call i64 @_D4core8internal4hash__T9bytesHashVbi0ZQpFNaNbNiNeMAxhmZm(i64 0, { i64, i8* } %2) #4 ; [#uses = 3]
  %.elt8 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack9 = load i64, i64* %.elt8, align 8      ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %.unpack9, 0 ; [#uses = 1]
  %.elt10 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack11 = load i8*, i8** %.elt10, align 8    ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %.unpack11, 1 ; [#uses = 1]
  %6 = tail call i64 @_D4core8internal4hash__T9bytesHashVbi0ZQpFNaNbNiNeMAxhmZm(i64 0, { i64, i8* } %5) #4 ; [#uses = 1]
  %7 = shl i64 %3, 6                              ; [#uses = 1]
  %8 = lshr i64 %3, 2                             ; [#uses = 1]
  %9 = add i64 %7, 2654435769                     ; [#uses = 1]
  %10 = add i64 %9, %8                            ; [#uses = 1]
  %11 = add i64 %10, %6                           ; [#uses = 1]
  %12 = xor i64 %11, %3                           ; [#uses = 1]
  ret i64 %12
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std8typecons__T5TupleTAaTQdZQn11__xopEqualsFKxSQBwQBv__TQBpTQBmTQBqZQCbKxQBbZb(%"std.typecons.Tuple!(char[], char[]).Tuple"* dereferenceable(32) %q, %"std.typecons.Tuple!(char[], char[]).Tuple"* dereferenceable(32) %p) #3 {
  %1 = tail call zeroext i1 @_D3std8typecons__T5TupleTAaTQdZQn__T8opEqualsTxSQBuQBt__TQBnTQBkTQBoZQBzZQBlMxFNaNbNiNfxQBpZb(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %p, %"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull byval align 8 %q) #4 ; [#uses = 1]
  ret i1 %1
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTAaTQdZQn8__xopCmpFKxSQBsQBr__TQBlTQBiTQBmZQBxKxQBbZi(%"std.typecons.Tuple!(char[], char[]).Tuple"* dereferenceable(32) %q, %"std.typecons.Tuple!(char[], char[]).Tuple"* dereferenceable(32) %p) #3 {
  %1 = tail call i32 @_D3std8typecons__T5TupleTAaTQdZQn__T5opCmpTxSQBrQBq__TQBkTQBhTQBlZQBwZQBiMxFNaNbNiNfxQBpZi(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %q, %"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull byval align 8 %p) #4 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D4core8internal4hash__T6hashOfTAxaZQmFNaNbNiNfMxAamZm(i64 %seed_arg, { i64, i8* } %val_arg) local_unnamed_addr #3 {
  %1 = tail call i64 @_D4core8internal4hash__T9bytesHashVbi0ZQpFNaNbNiNeMAxhmZm(i64 %seed_arg, { i64, i8* } %val_arg) #4 ; [#uses = 1]
  ret i64 %1
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std8typecons__T5TupleTAaTQdZQn__T5opCmpTxSQBrQBq__TQBkTQBhTQBlZQBwZQBiMxFNaNbNiNfxQBpZi(%"std.typecons.Tuple!(char[], char[]).Tuple"* nonnull %.this_arg, %"std.typecons.Tuple!(char[], char[]).Tuple"* byval align 8 %rhs) local_unnamed_addr #3 {
  %.elt = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 2, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt14 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 2, type = i8**]
  %.unpack15 = load i8*, i8** %.elt14, align 8    ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack15, 1 ; [#uses = 1]
  %.elt16 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack17 = load i64, i64* %.elt16, align 8    ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack17, 0 ; [#uses = 1]
  %.elt18 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack19 = load i8*, i8** %.elt18, align 8    ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack19, 1 ; [#uses = 2]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #4 ; [#uses = 1]
  br i1 %5, label %endif, label %condend.sink.split

condend.sink.split:                               ; preds = %0, %endif
  %.elt.sink = phi i64* [ %.elt20, %endif ], [ %.elt, %0 ] ; [#uses = 1, type = i64*]
  %.elt14.sink = phi i8** [ %.elt22, %endif ], [ %.elt14, %0 ] ; [#uses = 1, type = i8**]
  %.sink46 = phi { i64, i8* } [ %12, %endif ], [ %4, %0 ] ; [#uses = 1, type = { i64, i8* }]
  %.unpack37 = load i64, i64* %.elt.sink, align 8 ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack37, 0 ; [#uses = 1]
  %.unpack39 = load i8*, i8** %.elt14.sink, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack39, 1 ; [#uses = 1]
  %8 = tail call i32 @_D4core8internal6string__T7dstrcmpZQjFNaNbNiNeMxAaMxQeZi({ i64, i8* } %.sink46, { i64, i8* } %7) #4 ; [#uses = 1]
  %.inv = icmp sgt i32 %8, -1                     ; [#uses = 1]
  %. = select i1 %.inv, i32 1, i32 -1             ; [#uses = 1]
  br label %condend

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

endif:                                            ; preds = %0
  %.elt20 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 0 ; [#uses = 2, type = i64*]
  %.unpack21 = load i64, i64* %.elt20, align 8    ; [#uses = 1]
  %9 = insertvalue { i64, i8* } undef, i64 %.unpack21, 0 ; [#uses = 1]
  %.elt22 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %.this_arg, i64 0, i32 1, i32 1 ; [#uses = 2, type = i8**]
  %.unpack23 = load i8*, i8** %.elt22, align 8    ; [#uses = 1]
  %10 = insertvalue { i64, i8* } %9, i8* %.unpack23, 1 ; [#uses = 1]
  %.elt24 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 0 ; [#uses = 1, type = i64*]
  %.unpack25 = load i64, i64* %.elt24, align 8    ; [#uses = 1]
  %11 = insertvalue { i64, i8* } undef, i64 %.unpack25, 0 ; [#uses = 1]
  %.elt26 = getelementptr inbounds %"std.typecons.Tuple!(char[], char[]).Tuple", %"std.typecons.Tuple!(char[], char[]).Tuple"* %rhs, i64 0, i32 1, i32 1 ; [#uses = 1, type = i8**]
  %.unpack27 = load i8*, i8** %.elt26, align 8    ; [#uses = 1]
  %12 = insertvalue { i64, i8* } %11, i8* %.unpack27, 1 ; [#uses = 2]
  %13 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* } %12, { i64, i8* } %10) #4 ; [#uses = 1]
  br i1 %13, label %condend, label %condend.sink.split
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std6string__T10stripRightTAaZQqFNaNbNiNfQoZQr({ i64, i8* } %str_arg) local_unnamed_addr #3 {
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 5]
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 7]
  br label %forcond

forcond:                                          ; preds = %endif, %0
  %__key193.0 = phi i64 [ %str_arg.fca.0.extract, %0 ], [ %1, %endif ] ; [#uses = 16, type = i64]
  %1 = add i64 %__key193.0, -1                    ; [#uses = 2]
  %.not = icmp eq i64 %__key193.0, 0              ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody

forbody:                                          ; preds = %forcond
  %2 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %1 ; [#uses = 1, type = i8*]
  %3 = load i8, i8* %2, align 1                   ; [#uses = 2]
  %4 = icmp slt i8 %3, 0                          ; [#uses = 1]
  br i1 %4, label %if, label %endif

if:                                               ; preds = %forbody
  %bounds.cmp.up.not = icmp ugt i64 %__key193.0, %str_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail, label %forcond18

bounds.fail:                                      ; preds = %if
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3295, i64 0, i64 %__key193.0, i64 %str_arg.fca.0.extract) #5
  unreachable

endif:                                            ; preds = %forbody
  %5 = zext i8 %3 to i32                          ; [#uses = 1]
  %6 = tail call zeroext i1 @_D3std5ascii7isWhiteFNaNbNiNfwZb(i32 %5) #4 ; [#uses = 1]
  br i1 %6, label %forcond, label %if5

if5:                                              ; preds = %endif
  %bounds.cmp.up10.not = icmp ugt i64 %__key193.0, %str_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp.up10.not, label %bounds.fail8, label %bounds.ok7

bounds.ok7:                                       ; preds = %if5
  %7 = insertvalue { i64, i8* } undef, i64 %__key193.0, 0 ; [#uses = 1]
  %8 = insertvalue { i64, i8* } %7, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %8

bounds.fail8:                                     ; preds = %if5
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3300, i64 0, i64 %__key193.0, i64 %str_arg.fca.0.extract) #5
  unreachable

endfor:                                           ; preds = %forcond
  %9 = insertvalue { i64, i8* } { i64 0, i8* undef }, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %9

forcond18:                                        ; preds = %if, %forcond18.backedge
  %i16.0 = phi i64 [ %i16.0.be, %forcond18.backedge ], [ %__key193.0, %if ] ; [#uses = 7, type = i64]
  %10 = add i64 %i16.0, -1                        ; [#uses = 6]
  %.not101 = icmp eq i64 %i16.0, 0                ; [#uses = 1]
  br i1 %.not101, label %bounds.ok59, label %forbody19

forbody19:                                        ; preds = %forcond18
  %bounds.cmp = icmp ult i64 %10, %__key193.0     ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok23, label %bounds.fail24

bounds.ok23:                                      ; preds = %forbody19
  %11 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %10 ; [#uses = 1, type = i8*]
  %12 = load i8, i8* %11, align 1                 ; [#uses = 2]
  %13 = zext i8 %12 to i32                        ; [#uses = 3]
  %14 = icmp sgt i8 %12, -1                       ; [#uses = 1]
  br i1 %14, label %if26, label %else

if26:                                             ; preds = %bounds.ok23
  %15 = tail call zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32 %13) #4 ; [#uses = 1]
  br i1 %15, label %forcond18.backedge, label %endfor21

else:                                             ; preds = %bounds.ok23
  %16 = icmp eq i64 %10, 0                        ; [#uses = 1]
  %17 = and i32 %13, 192                          ; [#uses = 1]
  %18 = icmp ne i32 %17, 128                      ; [#uses = 1]
  %ororval = or i1 %16, %18                       ; [#uses = 1]
  br i1 %ororval, label %endfor21, label %endif31

endif31:                                          ; preds = %else
  %19 = and i32 %13, 63                           ; [#uses = 2]
  %20 = add i64 %i16.0, -2                        ; [#uses = 4]
  %bounds.cmp34 = icmp ult i64 %20, %__key193.0   ; [#uses = 1]
  br i1 %bounds.cmp34, label %bounds.ok35, label %bounds.fail36

bounds.ok35:                                      ; preds = %endif31
  %21 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %20 ; [#uses = 1, type = i8*]
  %22 = load i8, i8* %21, align 1                 ; [#uses = 1]
  %23 = zext i8 %22 to i32                        ; [#uses = 4]
  %24 = and i32 %23, 224                          ; [#uses = 1]
  %25 = icmp eq i32 %24, 192                      ; [#uses = 1]
  br i1 %25, label %if38, label %endif39

if38:                                             ; preds = %bounds.ok35
  %26 = shl nuw nsw i32 %23, 6                    ; [#uses = 1]
  %27 = and i32 %26, 1984                         ; [#uses = 1]
  %28 = or i32 %27, %19                           ; [#uses = 1]
  %29 = tail call zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32 %28) #4 ; [#uses = 1]
  br i1 %29, label %forcond18.backedge, label %endfor21

endif39:                                          ; preds = %bounds.ok35
  %30 = icmp eq i64 %10, 1                        ; [#uses = 1]
  %31 = and i32 %23, 192                          ; [#uses = 1]
  %32 = icmp ne i32 %31, 128                      ; [#uses = 1]
  %ororval46 = or i1 %30, %32                     ; [#uses = 1]
  br i1 %ororval46, label %endfor21, label %endif48

endif48:                                          ; preds = %endif39
  %33 = add i64 %i16.0, -3                        ; [#uses = 4]
  %bounds.cmp51 = icmp ult i64 %33, %__key193.0   ; [#uses = 1]
  br i1 %bounds.cmp51, label %bounds.ok52, label %bounds.fail53

bounds.ok52:                                      ; preds = %endif48
  %34 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %33 ; [#uses = 1, type = i8*]
  %35 = load i8, i8* %34, align 1                 ; [#uses = 1]
  %36 = zext i8 %35 to i32                        ; [#uses = 2]
  %37 = and i32 %36, 240                          ; [#uses = 1]
  %38 = icmp eq i32 %37, 224                      ; [#uses = 1]
  br i1 %38, label %andand, label %endfor21

andand:                                           ; preds = %bounds.ok52
  %39 = shl nuw nsw i32 %23, 6                    ; [#uses = 1]
  %40 = and i32 %39, 4032                         ; [#uses = 1]
  %41 = or i32 %40, %19                           ; [#uses = 1]
  %42 = shl nuw nsw i32 %36, 12                   ; [#uses = 1]
  %43 = and i32 %42, 61440                        ; [#uses = 1]
  %44 = or i32 %41, %43                           ; [#uses = 1]
  %45 = tail call zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32 %44) #4 ; [#uses = 1]
  br i1 %45, label %forcond18.backedge, label %endfor21

forcond18.backedge:                               ; preds = %andand, %if38, %if26
  %i16.0.be = phi i64 [ %10, %if26 ], [ %20, %if38 ], [ %33, %andand ] ; [#uses = 1, type = i64]
  br label %forcond18

bounds.fail53:                                    ; preds = %endif48
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3346, i64 %33, i64 %__key193.0) #5
  unreachable

bounds.fail36:                                    ; preds = %endif31
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3334, i64 %20, i64 %__key193.0) #5
  unreachable

bounds.fail24:                                    ; preds = %forbody19
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3322, i64 %10, i64 %__key193.0) #5
  unreachable

endfor21:                                         ; preds = %andand, %bounds.ok52, %endif39, %if38, %else, %if26
  %bounds.cmp.up62.not = icmp ugt i64 %i16.0, %__key193.0 ; [#uses = 1]
  br i1 %bounds.cmp.up62.not, label %bounds.fail60, label %bounds.ok59

bounds.ok59:                                      ; preds = %forcond18, %endfor21
  %i16.0.lcssa126 = phi i64 [ %i16.0, %endfor21 ], [ 0, %forcond18 ] ; [#uses = 1, type = i64]
  %46 = insertvalue { i64, i8* } undef, i64 %i16.0.lcssa126, 0 ; [#uses = 1]
  %47 = insertvalue { i64, i8* } %46, i8* %str_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %47

bounds.fail60:                                    ; preds = %endfor21
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3361, i64 0, i64 %i16.0, i64 %__key193.0) #5
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std6string__T9stripLeftTAaZQoFNaNbNiNfQoZQr({ i64, i8* } %input_arg) local_unnamed_addr #3 {
  %input = alloca { i64, i8* }, align 8           ; [#uses = 3, size/byte = 16]
  %index = alloca i64, align 8                    ; [#uses = 3, size/byte = 8]
  %input_arg.fca.0.extract = extractvalue { i64, i8* } %input_arg, 0 ; [#uses = 8]
  %input_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %input, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %input_arg.fca.0.extract, i64* %input_arg.fca.0.gep, align 8
  %input_arg.fca.1.extract = extractvalue { i64, i8* } %input_arg, 1 ; [#uses = 4]
  %input_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %input, i64 0, i32 1 ; [#uses = 4, type = i8**]
  store i8* %input_arg.fca.1.extract, i8** %input_arg.fca.1.gep, align 8
  br label %forcond

forcond:                                          ; preds = %forinc, %0
  %i.0 = phi i64 [ 0, %0 ], [ %6, %forinc ]       ; [#uses = 8, type = i64]
  %exitcond.not = icmp eq i64 %input_arg.fca.0.extract, %i.0 ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.ok5, label %bounds.ok

bounds.ok:                                        ; preds = %forcond
  %1 = getelementptr inbounds i8, i8* %input_arg.fca.1.extract, i64 %i.0 ; [#uses = 1, type = i8*]
  %2 = load i8, i8* %1, align 1                   ; [#uses = 2]
  %3 = icmp slt i8 %2, 0                          ; [#uses = 1]
  br i1 %3, label %bounds.ok10, label %endif

endif:                                            ; preds = %bounds.ok
  %4 = zext i8 %2 to i32                          ; [#uses = 1]
  %5 = tail call zeroext i1 @_D3std5ascii7isWhiteFNaNbNiNfwZb(i32 %4) #4 ; [#uses = 1]
  br i1 %5, label %forinc, label %endfor

forinc:                                           ; preds = %endif
  %6 = add i64 %i.0, 1                            ; [#uses = 1]
  br label %forcond

endfor:                                           ; preds = %endif
  %bounds.cmp.lo.not = icmp ult i64 %input_arg.fca.0.extract, %i.0 ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail6, label %bounds.ok5

bounds.ok5:                                       ; preds = %forcond, %endfor
  %i.0.lcssa66 = phi i64 [ %i.0, %endfor ], [ %input_arg.fca.0.extract, %forcond ] ; [#uses = 2, type = i64]
  %lowerbound = getelementptr inbounds i8, i8* %input_arg.fca.1.extract, i64 %i.0.lcssa66 ; [#uses = 1, type = i8*]
  %7 = sub i64 %input_arg.fca.0.extract, %i.0.lcssa66 ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %7, 0 ; [#uses = 1]
  %.fca.1.insert51 = insertvalue { i64, i8* } %.fca.0.insert, i8* %lowerbound, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert51

bounds.ok10:                                      ; preds = %bounds.ok
  %8 = getelementptr inbounds i8, i8* %input_arg.fca.1.extract, i64 %i.0 ; [#uses = 1, type = i8*]
  %9 = sub i64 %input_arg.fca.0.extract, %i.0     ; [#uses = 2]
  store i64 %9, i64* %input_arg.fca.0.gep, align 8
  store i8* %8, i8** %input_arg.fca.1.gep, align 8
  store i64 0, i64* %index, align 8
  br label %forcond16

forcond16:                                        ; preds = %forbody17.forcond16_crit_edge, %bounds.ok10
  %10 = phi i64 [ %.pre, %forbody17.forcond16_crit_edge ], [ 0, %bounds.ok10 ] ; [#uses = 5, type = i64]
  %.len20 = phi i64 [ %.len20.pre, %forbody17.forcond16_crit_edge ], [ %9, %bounds.ok10 ] ; [#uses = 2, type = i64]
  %11 = icmp ult i64 %10, %.len20                 ; [#uses = 1]
  br i1 %11, label %forbody17, label %bounds.ok33

forbody17:                                        ; preds = %forcond16
  %12 = call i32 @_D3std3utf__T6decodeVEQu8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai1TAaZQDgFNaNbNiNeKQqKmZw(i64* nonnull dereferenceable(8) %index, { i64, i8* }* nonnull dereferenceable(16) %input) #4 ; [#uses = 1]
  %13 = call zeroext i1 @_D3std3uni7isWhiteFNaNbNiNfwZb(i32 %12) #4 ; [#uses = 1]
  %.len20.pre = load i64, i64* %input_arg.fca.0.gep, align 8 ; [#uses = 5]
  br i1 %13, label %forbody17.forcond16_crit_edge, label %if21

forbody17.forcond16_crit_edge:                    ; preds = %forbody17
  %.pre = load i64, i64* %index, align 8          ; [#uses = 1]
  br label %forcond16

if21:                                             ; preds = %forbody17
  %bounds.cmp.lo27.not = icmp ult i64 %.len20.pre, %10 ; [#uses = 1]
  br i1 %bounds.cmp.lo27.not, label %bounds.fail25, label %bounds.ok24

bounds.ok24:                                      ; preds = %if21
  %.ptr28 = load i8*, i8** %input_arg.fca.1.gep, align 8 ; [#uses = 1]
  %lowerbound29 = getelementptr inbounds i8, i8* %.ptr28, i64 %10 ; [#uses = 1, type = i8*]
  %14 = sub i64 %.len20.pre, %10                  ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %lowerbound29, 1 ; [#uses = 1]
  ret { i64, i8* } %16

bounds.fail25:                                    ; preds = %if21
  call void @_d_arraybounds_slice({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3129, i64 %10, i64 %.len20.pre, i64 %.len20.pre) #5
  unreachable

bounds.ok33:                                      ; preds = %forcond16
  %.ptr37 = load i8*, i8** %input_arg.fca.1.gep, align 8 ; [#uses = 1]
  %lowerbound38 = getelementptr inbounds i8, i8* %.ptr37, i64 %.len20 ; [#uses = 1, type = i8*]
  %17 = insertvalue { i64, i8* } { i64 0, i8* undef }, i8* %lowerbound38, 1 ; [#uses = 1]
  ret { i64, i8* } %17

bounds.fail6:                                     ; preds = %endfor
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 52, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i32 0, i32 0) }, i32 3113, i64 %i.0, i64 %input_arg.fca.0.extract, i64 %input_arg.fca.0.extract) #5
  unreachable
}

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

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

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

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

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

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

else:                                             ; preds = %bounds.ok
  %12 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %13 = insertvalue { i64, i8* } %12, i8* %.ptr, 1 ; [#uses = 1]
  %14 = tail call i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai1TAxaZQDrFNaNbNiQoKmZw(i64* nonnull dereferenceable(8) %index, { i64, i8* } %13) #4 ; [#uses = 1]
  br label %label.__returnLabel

label.__returnLabel:                              ; preds = %else, %bounds.ok4
  %__result.0 = phi i32 [ %11, %bounds.ok4 ], [ %14, %else ] ; [#uses = 2, type = i32]
  %15 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %__result.0) #4 ; [#uses = 1]
  br i1 %15, label %assertPassed11, label %assertFailed12

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai1TAxaZQDrFNaNbNiQoKmZw(i64* dereferenceable(8) %index, { i64, i8* } %str_arg) local_unnamed_addr #3 {
  %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]
  %1 = load i64, i64* %index, align 8             ; [#uses = 13]
  %2 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %1 ; [#uses = 4, type = i8*]
  %3 = sub i64 %str_arg.fca.0.extract, %1         ; [#uses = 3]
  %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 = add i64 %1, 1                              ; [#uses = 1]
  store i64 %7, i64* %index, align 8
  ret i32 65533

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

if3:                                              ; preds = %endif
  %9 = add i64 %1, 1                              ; [#uses = 1]
  store i64 %9, i64* %index, align 8
  ret i32 65533

endif4:                                           ; preds = %endif
  %10 = getelementptr inbounds i8, i8* %2, i64 1  ; [#uses = 1, type = i8*]
  %11 = load i8, i8* %10, align 1                 ; [#uses = 1]
  %12 = zext i8 %11 to i32                        ; [#uses = 2]
  %13 = and i32 %12, 192                          ; [#uses = 1]
  %.not80 = icmp eq i32 %13, 128                  ; [#uses = 1]
  br i1 %.not80, label %endif7, label %if6

if6:                                              ; preds = %endif4
  %14 = add i64 %1, 2                             ; [#uses = 1]
  store i64 %14, i64* %index, align 8
  ret i32 65533

endif7:                                           ; preds = %endif4
  %15 = shl nuw nsw i32 %5, 6                     ; [#uses = 1]
  %16 = and i32 %12, 63                           ; [#uses = 1]
  %17 = or i32 %16, %15                           ; [#uses = 4]
  %.mask84 = and i8 %4, 32                        ; [#uses = 1]
  %18 = icmp eq i8 %.mask84, 0                    ; [#uses = 1]
  br i1 %18, label %if9, label %unrolledstmt1

if9:                                              ; preds = %endif7
  %19 = and i32 %5, 30                            ; [#uses = 1]
  %20 = icmp eq i32 %19, 0                        ; [#uses = 1]
  %21 = add i64 %1, 2                             ; [#uses = 1]
  store i64 %21, i64* %index, align 8
  br i1 %20, label %if11, label %endif12

if11:                                             ; preds = %if36, %endif39, %if9
  %merge = phi i32 [ 65533, %if9 ], [ %spec.select86, %endif39 ], [ 65533, %if36 ] ; [#uses = 1, type = i32]
  ret i32 %merge

endif12:                                          ; preds = %if9
  %22 = and i32 %17, 2047                         ; [#uses = 1]
  ret i32 %22

unrolledstmt1:                                    ; preds = %endif7
  %23 = icmp eq i64 %3, 2                         ; [#uses = 1]
  br i1 %23, label %if15, label %endif16

if15:                                             ; preds = %unrolledstmt1
  %24 = add i64 %1, 2                             ; [#uses = 1]
  store i64 %24, i64* %index, align 8
  ret i32 65533

endif16:                                          ; preds = %unrolledstmt1
  %25 = getelementptr inbounds i8, i8* %2, i64 2  ; [#uses = 1, type = i8*]
  %26 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %27 = zext i8 %26 to i32                        ; [#uses = 2]
  %28 = and i32 %27, 192                          ; [#uses = 1]
  %.not81 = icmp eq i32 %28, 128                  ; [#uses = 1]
  br i1 %.not81, label %endif19, label %if18

if18:                                             ; preds = %endif16
  %29 = add i64 %1, 3                             ; [#uses = 1]
  store i64 %29, i64* %index, align 8
  ret i32 65533

endif19:                                          ; preds = %endif16
  %30 = shl nuw nsw i32 %17, 6                    ; [#uses = 1]
  %31 = and i32 %27, 63                           ; [#uses = 1]
  %32 = or i32 %31, %30                           ; [#uses = 2]
  %.mask85 = and i8 %4, 16                        ; [#uses = 1]
  %33 = icmp eq i8 %.mask85, 0                    ; [#uses = 1]
  br i1 %33, label %if21, label %unrolledstmt2

if21:                                             ; preds = %endif19
  %34 = and i32 %32, 65535                        ; [#uses = 2]
  %35 = and i32 %17, 992                          ; [#uses = 1]
  %36 = icmp eq i32 %35, 0                        ; [#uses = 1]
  br i1 %36, label %if23, label %endif24

if23:                                             ; preds = %if21
  %37 = add i64 %1, 3                             ; [#uses = 1]
  store i64 %37, i64* %index, align 8
  ret i32 65533

endif24:                                          ; preds = %if21
  %38 = tail call zeroext i1 @_D3std3utf12isValidDcharFNaNbNiNfwZb(i32 %34) #4 ; [#uses = 1]
  %39 = load i64, i64* %index, align 8            ; [#uses = 1]
  %40 = add i64 %39, 3                            ; [#uses = 1]
  store i64 %40, i64* %index, align 8
  %spec.select = select i1 %38, i32 %34, i32 65533 ; [#uses = 1]
  ret i32 %spec.select

unrolledstmt2:                                    ; preds = %endif19
  %41 = icmp eq i64 %3, 3                         ; [#uses = 1]
  br i1 %41, label %if30, label %endif31

if30:                                             ; preds = %unrolledstmt2
  %42 = add i64 %1, 3                             ; [#uses = 1]
  store i64 %42, i64* %index, align 8
  ret i32 65533

endif31:                                          ; preds = %unrolledstmt2
  %43 = getelementptr inbounds i8, i8* %2, i64 3  ; [#uses = 1, type = i8*]
  %44 = load i8, i8* %43, align 1                 ; [#uses = 1]
  %45 = zext i8 %44 to i32                        ; [#uses = 2]
  %46 = and i32 %45, 192                          ; [#uses = 1]
  %.not82 = icmp eq i32 %46, 128                  ; [#uses = 1]
  br i1 %.not82, label %endif34, label %if33

if33:                                             ; preds = %endif31
  %47 = add i64 %1, 4                             ; [#uses = 1]
  store i64 %47, i64* %index, align 8
  ret i32 65533

endif34:                                          ; preds = %endif31
  %.mask = and i8 %4, 8                           ; [#uses = 1]
  %.not83 = icmp eq i8 %.mask, 0                  ; [#uses = 1]
  br i1 %.not83, label %if36, label %unrolledend

if36:                                             ; preds = %endif34
  %48 = shl nuw nsw i32 %32, 6                    ; [#uses = 1]
  %49 = and i32 %45, 63                           ; [#uses = 1]
  %.masked = and i32 %48, 2097088                 ; [#uses = 1]
  %50 = or i32 %49, %.masked                      ; [#uses = 2]
  %51 = and i32 %17, 496                          ; [#uses = 1]
  %52 = icmp eq i32 %51, 0                        ; [#uses = 1]
  %53 = add i64 %1, 4                             ; [#uses = 1]
  store i64 %53, i64* %index, align 8
  br i1 %52, label %if11, label %endif39

endif39:                                          ; preds = %if36
  %54 = icmp ugt i32 %50, 1114111                 ; [#uses = 1]
  %spec.select86 = select i1 %54, i32 65533, i32 %50 ; [#uses = 1]
  br label %if11

unrolledend:                                      ; preds = %endif34
  %55 = add i64 %1, 4                             ; [#uses = 1]
  store i64 %55, i64* %index, align 8
  ret i32 65533
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4_dupTxaTaZQlFNaNbNeMAxaZAa({ i64, i8* } %a_arg) local_unnamed_addr #3 {
  %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 = 2]
declare { i64, i8* } @_d_newarrayU(%object.TypeInfo*, i64) local_unnamed_addr #4

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

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

forbody:                                          ; preds = %forcond
  %2 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %__key196.0 ; [#uses = 1, type = i8*]
  %.appendedArray = call { i64, i8* } @_d_arrayappendcTX(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Aa6__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 i64 %__key196.0, 1                     ; [#uses = 1]
  br label %forcond

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

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

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr i64 @_D4core8internal4hash__T9bytesHashVbi0ZQpFNaNbNiNeMAxhmZm(i64 %seed_arg, { i64, i8* } %bytes_arg) local_unnamed_addr #3 {
  %bytes_arg.fca.0.extract = extractvalue { i64, i8* } %bytes_arg, 0 ; [#uses = 3]
  %bytes_arg.fca.1.extract = extractvalue { i64, i8* } %bytes_arg, 1 ; [#uses = 2]
  %1 = and i64 %bytes_arg.fca.0.extract, -4       ; [#uses = 1]
  %2 = trunc i64 %seed_arg to i32                 ; [#uses = 1]
  %3 = getelementptr inbounds i8, i8* %bytes_arg.fca.1.extract, i64 %1 ; [#uses = 4, type = i8*]
  br label %forcond

forcond:                                          ; preds = %forbody, %0
  %h1.0 = phi i32 [ %2, %0 ], [ %15, %forbody ]   ; [#uses = 3, type = i32]
  %data.0 = phi i8* [ %bytes_arg.fca.1.extract, %0 ], [ %16, %forbody ] ; [#uses = 3, type = i8*]
  %.not = icmp eq i8* %data.0, %3                 ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody

forbody:                                          ; preds = %forcond
  %4 = tail call i32 @_D4core8internal4hash__T9get32bitsZQlFNaNbNiMPxhZk(i8* %data.0) #4 ; [#uses = 2]
  %5 = mul i32 %4, -862048943                     ; [#uses = 1]
  %6 = mul i32 %4, 380141568                      ; [#uses = 1]
  %7 = lshr i32 %5, 17                            ; [#uses = 1]
  %8 = or i32 %7, %6                              ; [#uses = 1]
  %9 = mul i32 %8, 461845907                      ; [#uses = 1]
  %10 = xor i32 %9, %h1.0                         ; [#uses = 2]
  %11 = shl i32 %10, 13                           ; [#uses = 1]
  %12 = lshr i32 %10, 19                          ; [#uses = 1]
  %13 = or i32 %11, %12                           ; [#uses = 1]
  %14 = mul i32 %13, 5                            ; [#uses = 1]
  %15 = add i32 %14, -430675100                   ; [#uses = 1]
  %16 = getelementptr inbounds i8, i8* %data.0, i64 4 ; [#uses = 1, type = i8*]
  br label %forcond

endfor:                                           ; preds = %forcond
  %17 = and i64 %bytes_arg.fca.0.extract, 3       ; [#uses = 1]
  switch i64 %17, label %switchend [
    i64 3, label %case
    i64 2, label %goto_case
    i64 1, label %goto_case2
  ]

case:                                             ; preds = %endfor
  %18 = getelementptr inbounds i8, i8* %3, i64 2  ; [#uses = 1, type = i8*]
  %19 = load i8, i8* %18, align 1                 ; [#uses = 1]
  %20 = zext i8 %19 to i32                        ; [#uses = 1]
  %21 = shl nuw nsw i32 %20, 16                   ; [#uses = 1]
  br label %goto_case

goto_case:                                        ; preds = %endfor, %case
  %k11.0 = phi i32 [ 0, %endfor ], [ %21, %case ] ; [#uses = 1, type = i32]
  %22 = getelementptr inbounds i8, i8* %3, i64 1  ; [#uses = 1, type = i8*]
  %23 = load i8, i8* %22, align 1                 ; [#uses = 1]
  %24 = zext i8 %23 to i32                        ; [#uses = 1]
  %25 = shl nuw nsw i32 %24, 8                    ; [#uses = 1]
  %26 = or i32 %25, %k11.0                        ; [#uses = 1]
  br label %goto_case2

goto_case2:                                       ; preds = %endfor, %goto_case
  %k11.1 = phi i32 [ 0, %endfor ], [ %26, %goto_case ] ; [#uses = 1, type = i32]
  %27 = load i8, i8* %3, align 1                  ; [#uses = 1]
  %28 = zext i8 %27 to i32                        ; [#uses = 1]
  %29 = xor i32 %k11.1, %28                       ; [#uses = 2]
  %30 = mul i32 %29, -862048943                   ; [#uses = 1]
  %31 = mul i32 %29, 380141568                    ; [#uses = 1]
  %32 = lshr i32 %30, 17                          ; [#uses = 1]
  %33 = or i32 %32, %31                           ; [#uses = 1]
  %34 = mul i32 %33, 461845907                    ; [#uses = 1]
  %35 = xor i32 %34, %h1.0                        ; [#uses = 1]
  br label %switchend

switchend:                                        ; preds = %goto_case2, %endfor
  %h1.1 = phi i32 [ %h1.0, %endfor ], [ %35, %goto_case2 ] ; [#uses = 1, type = i32]
  %36 = trunc i64 %bytes_arg.fca.0.extract to i32 ; [#uses = 1]
  %37 = xor i32 %h1.1, %36                        ; [#uses = 2]
  %38 = lshr i32 %37, 16                          ; [#uses = 1]
  %39 = xor i32 %38, %37                          ; [#uses = 1]
  %40 = mul i32 %39, -2048144789                  ; [#uses = 2]
  %41 = lshr i32 %40, 13                          ; [#uses = 1]
  %42 = xor i32 %41, %40                          ; [#uses = 1]
  %43 = mul i32 %42, -1028477387                  ; [#uses = 2]
  %44 = lshr i32 %43, 16                          ; [#uses = 1]
  %45 = xor i32 %44, %43                          ; [#uses = 1]
  %46 = zext i32 %45 to i64                       ; [#uses = 1]
  ret i64 %46
}

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8internal4hash__T9get32bitsZQlFNaNbNiMPxhZk(i8* %x_arg) local_unnamed_addr #3 {
  %1 = getelementptr inbounds i8, i8* %x_arg, i64 3 ; [#uses = 1, type = i8*]
  %2 = load i8, i8* %1, align 1                   ; [#uses = 1]
  %3 = zext i8 %2 to i32                          ; [#uses = 1]
  %4 = shl nuw i32 %3, 24                         ; [#uses = 1]
  %5 = getelementptr inbounds i8, i8* %x_arg, i64 2 ; [#uses = 1, type = i8*]
  %6 = load i8, i8* %5, align 1                   ; [#uses = 1]
  %7 = zext i8 %6 to i32                          ; [#uses = 1]
  %8 = shl nuw nsw i32 %7, 16                     ; [#uses = 1]
  %9 = or i32 %8, %4                              ; [#uses = 1]
  %10 = getelementptr inbounds i8, i8* %x_arg, i64 1 ; [#uses = 1, type = i8*]
  %11 = load i8, i8* %10, align 1                 ; [#uses = 1]
  %12 = zext i8 %11 to i32                        ; [#uses = 1]
  %13 = shl nuw nsw i32 %12, 8                    ; [#uses = 1]
  %14 = or i32 %9, %13                            ; [#uses = 1]
  %15 = load i8, i8* %x_arg, align 1              ; [#uses = 1]
  %16 = zext i8 %15 to i32                        ; [#uses = 1]
  %17 = or i32 %14, %16                           ; [#uses = 1]
  ret i32 %17
}

; [#uses = 4]
declare zeroext i1 @_D4core8internal5array8equality__T8__equalsTaTaZQoFNaNbNiNeMxAaMxQeZb({ i64, i8* }, { i64, i8* }) local_unnamed_addr #4

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8internal5array10comparison__T5__cmpTaZQjFNaNbNiNeMxAaMxQeZi({ i64, i8* } %rhs_arg, { i64, i8* } %lhs_arg) local_unnamed_addr #3 {
  %1 = tail call i32 @_D4core8internal6string__T7dstrcmpZQjFNaNbNiNeMxAaMxQeZi({ i64, i8* } %rhs_arg, { i64, i8* } %lhs_arg) #4 ; [#uses = 1]
  ret i32 %1
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8internal6string__T7dstrcmpZQjFNaNbNiNeMxAaMxQeZi({ i64, i8* } %s2_arg, { i64, i8* } %s1_arg) local_unnamed_addr #3 {
condend:
  %s1_arg.fca.0.extract = extractvalue { i64, i8* } %s1_arg, 0 ; [#uses = 3]
  %s1_arg.fca.1.extract = extractvalue { i64, i8* } %s1_arg, 1 ; [#uses = 1]
  %s2_arg.fca.0.extract = extractvalue { i64, i8* } %s2_arg, 0 ; [#uses = 3]
  %s2_arg.fca.1.extract = extractvalue { i64, i8* } %s2_arg, 1 ; [#uses = 1]
  %.not = icmp ugt i64 %s1_arg.fca.0.extract, %s2_arg.fca.0.extract ; [#uses = 2]
  %s2_arg.fca.0.extract.s1_arg.fca.0.extract = select i1 %.not, i64 %s2_arg.fca.0.extract, i64 %s1_arg.fca.0.extract ; [#uses = 1]
  %0 = tail call i32 @memcmp(i8* %s1_arg.fca.1.extract, i8* %s2_arg.fca.1.extract, i64 %s2_arg.fca.0.extract.s1_arg.fca.0.extract) #4 ; [#uses = 2]
  %.not20 = icmp eq i32 %0, 0                     ; [#uses = 1]
  br i1 %.not20, label %endif, label %if

if:                                               ; preds = %condend
  ret i32 %0

endif:                                            ; preds = %condend
  %1 = zext i1 %.not to i32                       ; [#uses = 1]
  %2 = icmp ult i64 %s1_arg.fca.0.extract, %s2_arg.fca.0.extract ; [#uses = 1]
  %.neg = sext i1 %2 to i32                       ; [#uses = 1]
  %3 = add nsw i32 %.neg, %1                      ; [#uses = 1]
  ret i32 %3
}

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i32 @_D3std4conv__T6toImplTiTmZQmFNaNfmZi(i64 %value_arg) local_unnamed_addr #3 {
  %1 = icmp ugt i64 %value_arg, 2147483647        ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %0
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std4conv21ConvOverflowException7__ClassZ) #1 ; [#uses = 5]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %std.conv.ConvOverflowException* ; [#uses = 1]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D3std4conv21ConvOverflowException6__vtblZ, [10 x i8*]** %vtbl, align 8
  %2 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %2, align 8
  %3 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %4 = bitcast %object.Object* %3 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(60) %4, i8* nonnull align 8 dereferenceable(60) bitcast ({ i64, i8* }* getelementptr inbounds (%std.conv.ConvOverflowException, %std.conv.ConvOverflowException* @_D3std4conv21ConvOverflowException6__initZ, i64 0, i32 2) to i8*), i64 60, i1 false)
  %5 = tail call %std.conv.ConvOverflowException* @_D3std4conv21ConvOverflowException6__ctorMFNaNbNfAyaQdmZCQCdQCcQCa(%std.conv.ConvOverflowException* nonnull returned %.newclass_gc, i64 1539, { i64, i8* } { i64 50, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.13, i32 0, i32 0) }, { i64, i8* } { i64 28, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.12, i32 0, i32 0) }) #4 ; [#uses = 0]
  %6 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %6) #5
  unreachable

endif:                                            ; preds = %0
  %7 = trunc i64 %value_arg to i32                ; [#uses = 1]
  ret i32 %7
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 4]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %c_arg) local_unnamed_addr #3 {
  %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 = 1]
  store i64 %18, i64* %14, align 8
  %19 = getelementptr [4 x i8], [4 x i8]* %11, i64 0, i64 0 ; [#uses = 2, type = i8*]
  %20 = insertvalue { i64, i8* } { i64 4, i8* undef }, i8* %19, 1 ; [#uses = 1]
  %21 = tail call i32 @_D3std3utf__T6strideTAaZQlFNaNfQkZk({ i64, i8* } %20) #4 ; [#uses = 2]
  %22 = zext i32 %21 to i64                       ; [#uses = 3]
  %23 = load i64, i64* %14, align 8               ; [#uses = 1]
  %24 = icmp eq i64 %23, %22                      ; [#uses = 1]
  br i1 %24, label %if7, label %endif

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

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

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

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

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

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

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

bounds.fail10:                                    ; preds = %if7
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.14, i32 0, i32 0) }, i32 3305, i64 0, i64 %22, i64 4) #5
  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.14, i32 0, i32 0) }, i32 3301, i64 %15, i64 4) #5
  unreachable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

assertFailed:                                     ; preds = %0
  tail call void @_d_assert({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.6, i32 0, i32 0) }, i32 1281) #5
  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 #3 {
  %.frame = alloca %nest.decodeImpl.0, 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.0, %nest.decodeImpl.0* %.frame, i64 0, i32 0 ; [#uses = 1, type = i8**]
  %length = getelementptr inbounds %nest.decodeImpl.0, %nest.decodeImpl.0* %.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.0* %.frame to i8* ; [#uses = 1]
  %8 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %7) #3 ; [#uses = 1]
  %9 = bitcast %std.utf.UTFException* %8 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %9) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %12 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %11) #3 ; [#uses = 1]
  %13 = bitcast %std.utf.UTFException* %12 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %13) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %19 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %18) #3 ; [#uses = 1]
  %20 = bitcast %std.utf.UTFException* %19 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %20) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %28 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %27) #3 ; [#uses = 1]
  %29 = bitcast %std.utf.UTFException* %28 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %29) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %34 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %33) #3 ; [#uses = 1]
  %35 = bitcast %std.utf.UTFException* %34 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %35) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %41 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %40) #3 ; [#uses = 1]
  %42 = bitcast %std.utf.UTFException* %41 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %42) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %51 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %50) #3 ; [#uses = 1]
  %52 = bitcast %std.utf.UTFException* %51 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %52) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %55 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %54) #3 ; [#uses = 1]
  %56 = bitcast %std.utf.UTFException* %55 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %56) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %61 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %60) #3 ; [#uses = 1]
  %62 = bitcast %std.utf.UTFException* %61 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %62) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %68 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %67) #3 ; [#uses = 1]
  %69 = bitcast %std.utf.UTFException* %68 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %69) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %76 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %75) #3 ; [#uses = 1]
  %77 = bitcast %std.utf.UTFException* %76 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %77) #5
  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.0* %.frame to i8* ; [#uses = 1]
  %81 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %80) #3 ; [#uses = 1]
  %82 = bitcast %std.utf.UTFException* %81 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %82) #5
  unreachable

endif41:                                          ; preds = %endif38
  ret i32 %72

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } %msg_arg, { i64, i8* } %str_arg) local_unnamed_addr #3 {
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.6, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #5
  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.6, 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 #3 {
  %pstr = bitcast i8* %.nest_arg to i8**          ; [#uses = 1]
  %length = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %length to i64*                ; [#uses = 1]
  %2 = load i64, i64* %1, align 8                 ; [#uses = 1]
  %3 = load i8*, i8** %pstr, align 8              ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %2, 0  ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %3, 1     ; [#uses = 1]
  %6 = tail call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } { i64 44, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.5, i32 0, i32 0) }, { i64, i8* } %5) #4 ; [#uses = 1]
  ret %std.utf.UTFException* %6
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } %msg_arg) local_unnamed_addr #3 {
  %.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.6, 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) #5
  unreachable
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if:                                               ; preds = %0
  %4 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %5 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %4, align 8 ; [#uses = 1]
  %6 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %5, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %7 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %6, align 8 ; [#uses = 1]
  %8 = tail call i64 @_D3std5stdio__T13trustedFwriteTaZQsFNbNiNePOS4core4stdcQBx8_IO_FILExAaZm({ i64, i8* } %writeme_arg, %core.stdc.stdio._IO_FILE* %7) #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.14, i32 0, i32 0) }) #12
  unreachable

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5stdio__T13trustedFwriteTaZQsFNbNiNePOS4core4stdcQBx8_IO_FILExAaZm({ i64, i8* } %obj_arg, %core.stdc.stdio._IO_FILE* %f_arg) local_unnamed_addr #3 {
  %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 #3 {
  %.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) #12
  unreachable

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

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

; [#uses = 2]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #11 {
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 1]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std9exception14ErrnoException7__ClassZ) #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
  %4 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %msg_arg) #4 ; [#uses = 2]
  %.ptr1 = extractvalue { i64, i8* } %4, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %4, 0         ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %0, %condtrue
  %condtmp.0.sroa.phi.sroa.speculated = phi i64 [ %.len, %condtrue ], [ 18, %0 ] ; [#uses = 1, type = i64]
  %condtmp.0.sroa.phi7.sroa.speculated = phi i8* [ %.ptr1, %condtrue ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, 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) #5
  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 { i64, i8* } @_D6object__T4idupTxaZQjFNaNbNdNfAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #3 {
  %1 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %a_arg) #4 ; [#uses = 1]
  ret { i64, i8* } %1
}

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

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

forbody:                                          ; preds = %forcond
  %2 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %__key226.0 ; [#uses = 1, type = i8*]
  %.appendedArray = call { i64, i8* } @_d_arrayappendcTX(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Aya6__initZ to %object.TypeInfo*), { i64, i8* }* nonnull dereferenceable(16) %res, i64 1) #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 i64 %__key226.0, 1                     ; [#uses = 1]
  br label %forcond

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

; [#uses = 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 #3 {
  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) #12
  unreachable

endif:                                            ; preds = %0
  ret i1 true
}

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

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

; [#uses = 2]
; Function Attrs: noreturn uwtable
define weak_odr void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } %msg_arg, i64 %line_arg, { i64, i8* } %file_arg) local_unnamed_addr #11 {
  %.makelvaluetmp = alloca { i64, i8* }, align 8  ; [#uses = 2, size/byte = 16]
  %.makelvaluetmp2 = alloca { i64, i8* }, align 8 ; [#uses = 2, size/byte = 16]
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 1]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D9Exception7__ClassZ) #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
  %4 = tail call { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %msg_arg) #4 ; [#uses = 2]
  %.ptr1 = extractvalue { i64, i8* } %4, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %4, 0         ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.makelvaluetmp, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %5, align 8
  br label %condend

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

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

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

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

!llvm.ldc.typeinfo._D6source7Scanner7__ClassZ = !{!0}
!llvm.ldc.classinfo._D6source7Scanner7__ClassZ = !{!1}
!llvm.ldc.typeinfo._D6Object7__ClassZ = !{!2}
!llvm.ldc.classinfo._D6Object7__ClassZ = !{!3}
!llvm.ldc.typeinfo._D3std3utf12UTFException7__ClassZ = !{!4}
!llvm.ldc.classinfo._D3std3utf12UTFException7__ClassZ = !{!5}
!llvm.ldc.typeinfo._D42TypeInfo_xS3std8typecons__T5TupleTAaTQdZQn6__initZ = !{!6}
!llvm.ldc.typeinfo._D41TypeInfo_S3std8typecons__T5TupleTAaTQdZQn6__initZ = !{!6}
!llvm.ldc.typeinfo._D12TypeInfo_Axa6__initZ = !{!7}
!llvm.ldc.typeinfo._D11TypeInfo_Aa6__initZ = !{!7}
!llvm.ldc.typeinfo._D3std4conv21ConvOverflowException7__ClassZ = !{!8}
!llvm.ldc.classinfo._D3std4conv21ConvOverflowException7__ClassZ = !{!9}
!llvm.ldc.typeinfo._D3std9exception14ErrnoException7__ClassZ = !{!10}
!llvm.ldc.classinfo._D3std9exception14ErrnoException7__ClassZ = !{!11}
!llvm.ldc.typeinfo._D12TypeInfo_Aya6__initZ = !{!7}
!llvm.ldc.typeinfo._D9Exception7__ClassZ = !{!12}
!llvm.ldc.classinfo._D9Exception7__ClassZ = !{!13}
!llvm.ident = !{!14}

!0 = !{%source.Scanner* undef}
!1 = !{%source.Scanner undef, i1 true}
!2 = !{%object.Object* undef}
!3 = !{%object.Object undef, i1 false}
!4 = !{%std.utf.UTFException* undef}
!5 = !{%std.utf.UTFException undef, i1 false}
!6 = !{%"std.typecons.Tuple!(char[], char[]).Tuple" undef}
!7 = !{{ i64, i8* } undef}
!8 = !{%std.conv.ConvOverflowException* undef}
!9 = !{%std.conv.ConvOverflowException undef, i1 false}
!10 = !{%std.exception.ErrnoException* undef}
!11 = !{%std.exception.ErrnoException undef, i1 false}
!12 = !{%object.Exception* undef}
!13 = !{%object.Exception undef, i1 false}
!14 = !{!"ldc version 1.28.0"}
