//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;

final class InputReader {
  private:
  ubyte[] p, buffer;
  bool eof;
  bool rawRead () {
    if (eof) {
      return false;
    }
    p = stdin.rawRead (buffer);
    if (p.empty) {
      eof = true;
      return false;
    }
    return true;
  }
  ubyte nextByte(bool check) () {
    static if (check) {
      if (p.empty) {
        if (!rawRead ()) {
          return 0;
        }
      }
    }
    auto r = p.front;
    p.popFront ();
    return r;
  }
  public:
  this () {
    buffer = uninitializedArray!(ubyte[])(16<<20);
  }
  bool seekByte (in ubyte lo) {
    while (true) {
      p = p.find! (c => c >= lo);
      if (!p.empty) {
        return false;
      }
      if (!rawRead ()) {
        return true;
      }
    }
  }
  template next(T) if (isSigned!T) {
    T next ()  {
      if (seekByte (45)) {
        return 0;
      }
      T res;
      ubyte b = nextByte!false ();
      if (b == 45) {
        while (true) {
          b = nextByte!true ();
          if (b < 48 || b >= 58) {
            return res;
          }
          res = res * 10 - (b - 48);
        }
      } else {
        res = b - 48;
        while (true) {
          b = nextByte!true ();
          if (b < 48 || b >= 58) {
            return res;
          }
          res = res * 10 + (b - 48);
        }
      }
    }
  }
  template next(T) if (isUnsigned!T) {
    T next () {
      if (seekByte (48)) {
        return 0;
      }
      T res = nextByte!false () - 48;
      while (true) {
        ubyte b = nextByte!true ();
        if (b < 48 || b >= 58) {
          break;
        }
        res = res * 10 + (b - 48);
      }
      return res;
    }
  }
  T[] nextA(T) (in int n) {
    auto a = uninitializedArray!(T[]) (n);
    foreach (i; 0 .. n) {
      a[i] = next!T;
    }
    return a;
  }
}

void main() {
  auto r = new InputReader ();
  immutable nt = r.next!uint ();
  int[] ra (int n) {
    auto a = r.nextA!int (n);
    sort (a);
    return a;
  }
  foreach (tid; 0 .. nt) {
    long res = long.max;
    auto a = r.nextA!uint (3);
    auto t = new int[][3];
    foreach (k; 0 .. 3) t[k] = ra (a[k]);
    void check (long u, long v, long w) {
      long q = (u - v) * (u - v);
      q += (u - w) * (u - w);
      q += (v - w) * (v - w);
      if (res > q) res = q;
    }
    void f (in int[] x, in int[] y, in int[] z) {
      size_t j, k;
      foreach (i; 0 .. x.length) {
        int xv = x[i];
        while (j < y.length && y[j] < xv) ++j; 
        while (k < z.length && z[k] < xv) ++k; 
        void go (size_t u, size_t v) {
          if (u < y.length && v < z.length)
            check (xv, y[u], z[v]);
        }
        go (j, k);
        if (k > 0) {
          go (j, k - 1);
        }
        if (j > 0) {
          go (j - 1, k);
          if (k > 0) {
            go (j - 1, k - 1);
          }
        }
      }
    }
    f (t[0], t[1], t[2]);
    f (t[1], t[0], t[2]);
    f (t[2], t[0], t[1]);
    writeln (res);
  }
}


; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/D/Source_1861/source.d'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/D/Source_1861/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] }
%source.InputReader = type <{ [5 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i8 }>
%object.TypeInfo_Class = type { [20 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, { i64, i8** }, { i64, %object.Interface* }, %object.TypeInfo_Class*, i8*, void (%object.Object*)*, i32, [4 x i8], i8*, { i64, %object.OffsetTypeInfo* }, void (%object.Object*)*, i8* }
%object.Interface = type { %object.TypeInfo_Class*, { i64, i8** }, i64 }
%object.OffsetTypeInfo = type { i64, %object.TypeInfo* }
%object.TypeInfo = type { [19 x i8*]*, i8* }
%object.Object = type { [5 x i8*]*, i8* }
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%object.Exception = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.Throwable.TraceInfo = type { [4 x i8*]* }
%object.Throwable = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%std.exception.ErrnoException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, i32 }>
%object.TypeInfo_Const = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%std.utf.UTFException = type <{ [11 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, [4 x i8], i64, [4 x i32], i64 }>
%object.ModuleInfo = type { i32, i32 }
%std.stdio.File = 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] }
%nest.main = type { %source.InputReader*, i64 }
%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" = type { { i64, i32* } }
%std.stdio.File.LockingTextWriter = type { %std.stdio.File, i32, i16, [4 x i8], [6 x i8], i64 }
%nest.decodeImpl = type { i8*, i64 }

@_D6source11InputReader6__initZ = constant %source.InputReader <{ [5 x i8*]* @_D6source11InputReader6__vtblZ, i8* null, { i64, i8* } zeroinitializer, { i64, i8* } zeroinitializer, i8 0 }>, align 8 ; [#uses = 2]
@_D6source11InputReader6__vtblZ = constant [5 x i8*] [i8* bitcast (%object.TypeInfo_Class* @_D6source11InputReader7__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]
@_D6source11InputReader7__ClassZ = global %object.TypeInfo_Class { [20 x i8*]* @_D14TypeInfo_Class6__vtblZ, i8* null, { i64, i8* } { i64 49, i8* bitcast (%source.InputReader* @_D6source11InputReader6__initZ to i8*) }, { i64, i8* } { i64 18, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0) }, { i64, i8** } { i64 5, i8** getelementptr inbounds ([5 x i8*], [5 x i8*]* @_D6source11InputReader6__vtblZ, i32 0, i32 0) }, { i64, %object.Interface* } zeroinitializer, %object.TypeInfo_Class* @_D6Object7__ClassZ, i8* null, void (%object.Object*)* null, i32 60, [4 x i8] zeroinitializer, i8* null, { i64, %object.OffsetTypeInfo* } zeroinitializer, void (%object.Object*)* bitcast (%source.InputReader* (%source.InputReader*)* @_D6source11InputReader6__ctorMFZCQBfQBb to void (%object.Object*)*), i8* bitcast ([2 x i64]* @_D6object__T10RTInfoImplVAmA2i49i40ZQyyG2m to i8*) } ; [#uses = 3]
@_D14TypeInfo_Class6__vtblZ = external constant [20 x i8*] ; [#uses = 1]
@.str = private unnamed_addr constant [19 x i8] c"source.InputReader\00" ; [#uses = 1]
@_D6Object7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i49i40ZQyyG2m = weak_odr constant [2 x i64] [i64 49, i64 40], align 8 ; [#uses = 1]
@_D14TypeInfo_Array6__vtblZ = external constant [19 x i8*] ; [#uses = 1]
@_D11TypeInfo_Ai6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.1 = private unnamed_addr constant [61 x i8] c"/data/TheStack_IR/OJ_Samples/Collated/D/Source_1861/source.d\00" ; [#uses = 1]
@_D9Exception7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 2]
@_D9Exception6__vtblZ = external constant [10 x i8*] ; [#uses = 2]
@_D9Exception6__initZ = external local_unnamed_addr constant %object.Exception, align 8 ; [#uses = 1]
@.str.2 = private unnamed_addr constant [37 x i8] c"rawRead must take a non-empty buffer\00" ; [#uses = 1]
@.str.3 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/stdio.d\00" ; [#uses = 1]
@.str.4 = private unnamed_addr constant [41 x i8] c"Attempting to read from an unopened file\00" ; [#uses = 1]
@.str.5 = private unnamed_addr constant [19 x i8] c"Enforcement failed\00" ; [#uses = 1]
@_D12TypeInfo_Axa6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D12TypeInfo_Aya6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_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.6 = private unnamed_addr constant [57 x i8] c"Attempting to fetch the front of an empty array of ubyte\00" ; [#uses = 1]
@.str.7 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/primitives.d\00" ; [#uses = 1]
@_D11TypeInfo_Ah6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.8 = private unnamed_addr constant [59 x i8] c"Attempting to popFront() past the end of an array of ubyte\00" ; [#uses = 1]
@.str.9 = private unnamed_addr constant [55 x i8] c"Attempting to fetch the front of an empty array of int\00" ; [#uses = 1]
@.str.10 = private unnamed_addr constant [57 x i8] c"Attempting to popFront() past the end of an array of int\00" ; [#uses = 1]
@.str.11 = private unnamed_addr constant [54 x i8] c"Attempting to fetch the back of an empty array of int\00" ; [#uses = 1]
@.str.12 = private unnamed_addr constant [35 x i8] c"Failed to sort range of type int[]\00" ; [#uses = 1]
@.str.13 = private unnamed_addr constant [64 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/algorithm/sorting.d\00" ; [#uses = 1]
@.str.14 = private unnamed_addr constant [60 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d\00" ; [#uses = 1]
@.str.15 = private unnamed_addr constant [80 x i8] c"Attempting to slice a SortedRange with a larger first argument than the second.\00" ; [#uses = 1]
@_D12TypeInfo_xAi6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axi6__initZ to %object.TypeInfo*) } ; [#uses = 2]
@_D14TypeInfo_Const6__vtblZ = external constant [19 x i8*] ; [#uses = 2]
@_D12TypeInfo_Axi6__initZ = linkonce_odr global %object.TypeInfo_Array { [19 x i8*]* @_D14TypeInfo_Array6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Const* @_D11TypeInfo_xi6__initZ to %object.TypeInfo*) } ; [#uses = 1]
@_D11TypeInfo_xi6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_i6__initZ } ; [#uses = 1]
@_D10TypeInfo_i6__initZ = external global %object.TypeInfo ; [#uses = 1]
@.str.16 = private unnamed_addr constant [35 x i8] c"sort: invalid comparison function.\00" ; [#uses = 1]
@.str.17 = private unnamed_addr constant [16 x i8] c"r is not a heap\00" ; [#uses = 1]
@.str.18 = private unnamed_addr constant [65 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/algorithm/mutation.d\00" ; [#uses = 1]
@.str.19 = private unnamed_addr constant [49 x i8] c"r.length must be greater equal to Indexes.length\00" ; [#uses = 1]
@.str.20 = private unnamed_addr constant [8 x i8] c"a != b \00" ; [#uses = 1]
@.str.21 = private unnamed_addr constant [17 x i8] c"a != c && b != c\00" ; [#uses = 1]
@.str.22 = private unnamed_addr constant [23 x i8] c"less than check failed\00" ; [#uses = 1]
@.str.23 = private unnamed_addr constant [34 x i8] c"a != d && b != d && c != d failed\00" ; [#uses = 1]
@.str.24 = private unnamed_addr constant [44 x i8] c"a != e && b != e && c != e && d != e failed\00" ; [#uses = 1]
@.str.25 = private unnamed_addr constant [28 x i8] c"Swap: lhs internal pointer.\00" ; [#uses = 1]
@.str.26 = private unnamed_addr constant [28 x i8] c"Swap: rhs internal pointer.\00" ; [#uses = 1]
@.str.27 = private unnamed_addr constant [25 x i8] c"Swap: lhs points to rhs.\00" ; [#uses = 1]
@.str.28 = private unnamed_addr constant [25 x i8] c"Swap: rhs points to lhs.\00" ; [#uses = 1]
@.str.30 = private unnamed_addr constant [33 x i8] c"r must have more than 4 elements\00" ; [#uses = 1]
@.str.31 = private unnamed_addr constant [17 x i8] c"unexpected order\00" ; [#uses = 1]
@_D11TypeInfo_Ak6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D3std3utf12UTFException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 8]
@.str.33 = private unnamed_addr constant [50 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/utf.d\00" ; [#uses = 1]
@.str.34 = private unnamed_addr constant [23 x i8] c"Invalid UTF-8 sequence\00" ; [#uses = 1]
@.str.35 = private unnamed_addr constant [45 x i8] c"Attempted to decode past the end of a string\00" ; [#uses = 1]
@_D3std3utf12UTFException6__vtblZ = external constant [11 x i8*] ; [#uses = 5]
@_D3std3utf12UTFException6__initZ = external local_unnamed_addr constant %std.utf.UTFException, align 8 ; [#uses = 1]
@.str.36 = private unnamed_addr constant [41 x i8] c"Encoding an invalid code point in UTF-32\00" ; [#uses = 1]
@.str.37 = private unnamed_addr constant [63 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/core/internal/string.d\00" ; [#uses = 1]
@.str.38 = private unnamed_addr constant [73 x i8] c"Cannot move object with internal pointer unless `opPostMove` is defined.\00" ; [#uses = 1]
@_D6object__T10RTInfoImplVAmA2i16i2ZQxyG2m = weak_odr local_unnamed_addr constant [2 x i64] [i64 16, i64 2], align 8 ; [#uses = 0]
@_D6source12__ModuleInfoZ = global %0 { i32 -2147481596, i32 0, i64 1, [1 x %object.TypeInfo_Class*] [%object.TypeInfo_Class* @_D6source11InputReader7__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 = 0]
; Function Attrs: uwtable
define zeroext i1 @_D6source11InputReader7rawReadMFZb(%source.InputReader* nocapture nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 4 ; [#uses = 2, type = i8*]
  %2 = load i8, i8* %1, align 1, !range !15       ; [#uses = 1]
  %.not = icmp eq i8 %2, 0                        ; [#uses = 1]
  br i1 %.not, label %endif, label %if

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

endif:                                            ; preds = %0
  %3 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.elt = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %4 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt9 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 1, type = i8**]
  %.unpack10 = load i8*, i8** %.elt9, align 8     ; [#uses = 1]
  %5 = insertvalue { i64, i8* } %4, i8* %.unpack10, 1 ; [#uses = 1]
  %6 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %3, { i64, i8* } %5) #1 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %6, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %6, 0         ; [#uses = 2]
  %7 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %7, align 8
  %8 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr, i8** %8, align 8
  %.not.i = icmp eq i64 %.len, 0                  ; [#uses = 1]
  br i1 %.not.i, label %if1, label %if

if1:                                              ; preds = %endif
  store i8 1, i8* %1, align 1
  ret i1 false
}

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

; [#uses = 8]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %.this_arg, { i64, i8* } %buffer_arg) local_unnamed_addr #0 {
  %.getAddressOf_dump = alloca { i64, i8* }, align 8 ; [#uses = 3, size/byte = 16]
  %buffer_arg.fca.0.extract = extractvalue { i64, i8* } %buffer_arg, 0 ; [#uses = 4]
  %.not = icmp eq i64 %buffer_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not, label %if, label %endif

if:                                               ; preds = %0
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D9Exception7__ClassZ) #4 ; [#uses = 5]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %object.Exception* ; [#uses = 1]
  %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)
  %.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.getAddressOf_dump, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 36, i64* %.fca.0.gep, align 8
  %.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.getAddressOf_dump, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.2, i64 0, i64 0), i8** %.fca.1.gep, align 8
  %4 = tail call %object.Exception* @_D6object9Exception6__ctorMFNaNbNiNfAyaQdmCQBp9ThrowableZCQBx(%object.Exception* nonnull returned %.newclass_gc, %object.Throwable* null, i64 1236, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.getAddressOf_dump) #1 ; [#uses = 0]
  %5 = bitcast %object.Object* %.newclass_gc_alloc to %object.Throwable* ; [#uses = 1]
  tail call void @_d_throw_exception(%object.Throwable* %5) #5
  unreachable

endif:                                            ; preds = %0
  %6 = tail call zeroext i1 @_D3std5stdio4File6isOpenMxFNaNbNdNfZb(%std.stdio.File* nonnull %.this_arg) #1 ; [#uses = 1]
  br i1 %6, label %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit, label %if.i

if.i:                                             ; preds = %endif
  tail call void @_D3std9exception__T7bailOutHTC9ExceptionZQwFNaNfAyamMAxaZNn({ i64, i8* } { i64 40, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.4, i32 0, i32 0) }, i64 1237, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }) #14
  unreachable

_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit: ; preds = %endif
  %7 = getelementptr inbounds %std.stdio.File, %std.stdio.File* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %8 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %7, align 8 ; [#uses = 1]
  %9 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %8, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %10 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %9, align 8 ; [#uses = 1]
  %obj_arg.fca.1.extract.i = extractvalue { i64, i8* } %buffer_arg, 1 ; [#uses = 2]
  %11 = tail call i64 @fread(i8* %obj_arg.fca.1.extract.i, i64 1, i64 %buffer_arg.fca.0.extract, %core.stdc.stdio._IO_FILE* %10) #1 ; [#uses = 3]
  %.not29 = icmp ugt i64 %11, %buffer_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not29, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit
  %.not30 = icmp eq i64 %11, %buffer_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not30, label %endif4, label %if3

if3:                                              ; preds = %assertPassed
  %12 = tail call zeroext i1 @_D3std5stdio4File5errorMxFNaNbNdNeZb(%std.stdio.File* nonnull %.this_arg) #1 ; [#uses = 1]
  br i1 %12, label %if.i31, label %_D3std9exception__T7enforceHTCQBcQBb14ErrnoExceptionZ__TQBlTbZQBrFNfbLAxaAyamZb.exit

if.i31:                                           ; preds = %if3
  tail call void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } zeroinitializer, i64 1257, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }) #14
  unreachable

_D3std9exception__T7enforceHTCQBcQBb14ErrnoExceptionZ__TQBlTbZQBrFNfbLAxaAyamZb.exit: ; preds = %if3
  %13 = insertvalue { i64, i8* } undef, i64 %11, 0 ; [#uses = 1]
  %14 = insertvalue { i64, i8* } %13, i8* %obj_arg.fca.1.extract.i, 1 ; [#uses = 1]
  ret { i64, i8* } %14

endif4:                                           ; preds = %assertPassed
  ret { i64, i8* } %buffer_arg

assertFailed:                                     ; preds = %_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb.exit
  tail call void @_d_assert({ i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }, i32 1254) #5
  unreachable
}

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

; [#uses = 1]
; Function Attrs: uwtable
define nonnull %source.InputReader* @_D6source11InputReader6__ctorMFZCQBfQBb(%source.InputReader* nonnull returned %.this_arg) #0 {
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 16777216) #8 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %1, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %1, 0         ; [#uses = 1]
  %2 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %2, align 8
  %3 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr, i8** %3, align 8
  ret %source.InputReader* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T18uninitializedArrayTAhTiZQBaFNaNbNeiZQr(i32 %_param_0_arg) local_unnamed_addr #0 {
  %1 = sext i32 %_param_0_arg to i64              ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 %1) #8 ; [#uses = 1]
  ret { i64, i8* } %2
}

; [#uses = 0]
; Function Attrs: uwtable
define zeroext i1 @_D6source11InputReader8seekByteMFIhZb(%source.InputReader* nocapture nonnull %.this_arg, i8 zeroext %lo_arg) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 4, type = i64*]
  %.elt8 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 4, type = i8**]
  %1 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 4 ; [#uses = 2, type = i8*]
  %.elt.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 1, type = i64*]
  %.elt9.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 1, type = i8**]
  %.unpack.pre = load i64, i64* %.elt, align 8    ; [#uses = 1]
  %.unpack9.pre = load i8*, i8** %.elt8, align 8  ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %endif.i, %0
  %.unpack9 = phi i8* [ %.ptr.i, %endif.i ], [ %.unpack9.pre, %0 ] ; [#uses = 3, type = i8*]
  %.unpack = phi i64 [ %.len.i, %endif.i ], [ %.unpack.pre, %0 ] ; [#uses = 3, type = i64]
  %.not.i20.i = icmp eq i64 %.unpack, 0           ; [#uses = 1]
  br i1 %.not.i20.i, label %endif, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i: ; preds = %forcond
  %scevgep.i = getelementptr i8, i8* %.unpack9, i64 %.unpack ; [#uses = 1, type = i8*]
  br label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i: ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i
  %haystack.sroa.0.022.i = phi i64 [ %.unpack, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i ], [ %3, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i ] ; [#uses = 2, type = i64]
  %haystack.sroa.6.021.i = phi i8* [ %.unpack9, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i ], [ %lowerbound.i.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i ] ; [#uses = 3, type = i8*]
  %2 = load i8, i8* %haystack.sroa.6.021.i, align 1 ; [#uses = 1]
  %.not.i = icmp ult i8 %2, %lo_arg               ; [#uses = 1]
  br i1 %.not.i, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i, label %_D3std9algorithm9searching__T4findS6source11InputReader8seekByteMFIhZ9__lambda2TAhZQCcMFNaNbNiNfQqZQt.exit

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i
  %lowerbound.i.i = getelementptr inbounds i8, i8* %haystack.sroa.6.021.i, i64 1 ; [#uses = 1, type = i8*]
  %3 = add i64 %haystack.sroa.0.022.i, -1         ; [#uses = 2]
  %.not.i.i = icmp eq i64 %3, 0                   ; [#uses = 1]
  br i1 %.not.i.i, label %endif, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i

_D3std9algorithm9searching__T4findS6source11InputReader8seekByteMFIhZ9__lambda2TAhZQCcMFNaNbNiNfQqZQt.exit: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i
  store i64 %haystack.sroa.0.022.i, i64* %.elt, align 8
  store i8* %haystack.sroa.6.021.i, i8** %.elt8, align 8
  br label %if

if:                                               ; preds = %endif, %if1.i, %_D3std9algorithm9searching__T4findS6source11InputReader8seekByteMFIhZ9__lambda2TAhZQCcMFNaNbNiNfQqZQt.exit
  %merge = phi i1 [ false, %_D3std9algorithm9searching__T4findS6source11InputReader8seekByteMFIhZ9__lambda2TAhZQCcMFNaNbNiNfQqZQt.exit ], [ true, %if1.i ], [ true, %endif ] ; [#uses = 1, type = i1]
  ret i1 %merge

endif:                                            ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i, %forcond
  %haystack.sroa.6.0.lcssa.i.ph = phi i8* [ %.unpack9, %forcond ], [ %scevgep.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i ] ; [#uses = 1, type = i8*]
  store i64 0, i64* %.elt, align 8
  store i8* %haystack.sroa.6.0.lcssa.i.ph, i8** %.elt8, align 8
  %4 = load i8, i8* %1, align 1, !range !15       ; [#uses = 1]
  %.not.i10 = icmp eq i8 %4, 0                    ; [#uses = 1]
  br i1 %.not.i10, label %endif.i, label %if

endif.i:                                          ; preds = %endif
  %5 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i = load i64, i64* %.elt.i, align 8    ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack.i, 0 ; [#uses = 1]
  %.unpack10.i = load i8*, i8** %.elt9.i, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack10.i, 1 ; [#uses = 1]
  %8 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %5, { i64, i8* } %7) #1 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %8, 1       ; [#uses = 2]
  %.len.i = extractvalue { i64, i8* } %8, 0       ; [#uses = 3]
  store i64 %.len.i, i64* %.elt, align 8
  store i8* %.ptr.i, i8** %.elt8, align 8
  %.not.i.i11 = icmp eq i64 %.len.i, 0            ; [#uses = 1]
  br i1 %.not.i.i11, label %if1.i, label %forcond

if1.i:                                            ; preds = %endif.i
  store i8 1, i8* %1, align 1
  br label %if
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm9searching__T4findS6source11InputReader8seekByteMFIhZ9__lambda2TAhZQCcMFNaNbNiNfQqZQt(i8* nonnull %.nest_arg, { i64, i8* } %haystack_arg) local_unnamed_addr #0 {
  %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 = 3]
  %.not.i20 = icmp eq i64 %haystack_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not.i20, label %endfor, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph: ; preds = %0
  %1 = load i8, i8* %.nest_arg, align 1           ; [#uses = 1]
  %scevgep = getelementptr i8, i8* %haystack_arg.fca.1.extract, i64 %haystack_arg.fca.0.extract ; [#uses = 1, type = i8*]
  br label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit
  %haystack.sroa.0.022 = phi i64 [ %haystack_arg.fca.0.extract, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph ], [ %3, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit ] ; [#uses = 2, type = i64]
  %haystack.sroa.6.021 = phi i8* [ %haystack_arg.fca.1.extract, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph ], [ %lowerbound.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit ] ; [#uses = 3, type = i8*]
  %2 = load i8, i8* %haystack.sroa.6.021, align 1 ; [#uses = 1]
  %.not = icmp ugt i8 %1, %2                      ; [#uses = 1]
  br i1 %.not, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit, label %endfor

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit
  %lowerbound.i = getelementptr inbounds i8, i8* %haystack.sroa.6.021, i64 1 ; [#uses = 1, type = i8*]
  %3 = add i64 %haystack.sroa.0.022, -1           ; [#uses = 2]
  %.not.i = icmp eq i64 %3, 0                     ; [#uses = 1]
  br i1 %.not.i, label %endfor, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit

endfor:                                           ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit, %0
  %haystack.sroa.6.0.lcssa = phi i8* [ %haystack_arg.fca.1.extract, %0 ], [ %haystack.sroa.6.021, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit ], [ %scevgep, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit ] ; [#uses = 1, type = i8*]
  %haystack.sroa.0.0.lcssa = phi i64 [ 0, %0 ], [ %haystack.sroa.0.022, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit ], [ 0, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit ] ; [#uses = 1, type = i64]
  %.fca.0.insert3 = insertvalue { i64, i8* } undef, i64 %haystack.sroa.0.0.lcssa, 0 ; [#uses = 1]
  %.fca.1.insert12 = insertvalue { i64, i8* } %.fca.0.insert3, i8* %haystack.sroa.6.0.lcssa, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert12
}

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

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #3 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
  %.nongc_mem110 = alloca [3 x { i64, i32* }], align 8 ; [#uses = 14, size/byte = 48]
  %.nongc_mem110.sub = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 0 ; [#uses = 1, type = { i64, i32* }*]
  %1 = bitcast [3 x { i64, i32* }]* %.nongc_mem110 to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(48) %1, i8 0, i64 48, i1 false)
  %__tmpfordtor204.i = alloca %std.stdio.File, align 8 ; [#uses = 5, size/byte = 24]
  %.frame = alloca %nest.main, align 8            ; [#uses = 4, size/byte = 16]
  %r = getelementptr inbounds %nest.main, %nest.main* %.frame, i64 0, i32 0 ; [#uses = 1, type = %source.InputReader**]
  %res = getelementptr inbounds %nest.main, %nest.main* %.frame, i64 0, i32 1 ; [#uses = 3, type = i64*]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D6source11InputReader7__ClassZ) #4 ; [#uses = 7]
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %source.InputReader* ; [#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*]* @_D6source11InputReader6__vtblZ, [5 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(33) %4, i8* nonnull align 8 dereferenceable(33) bitcast ({ i64, i8* }* getelementptr inbounds (%source.InputReader, %source.InputReader* @_D6source11InputReader6__initZ, i64 0, i32 2) to i8*), i64 33, i1 false)
  %5 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 16777216) #8 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %5, 1       ; [#uses = 1]
  %.len.i = extractvalue { i64, i8* } %5, 0       ; [#uses = 1]
  %6 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 2 ; [#uses = 1, type = %object.Object*]
  %7 = bitcast %object.Object* %6 to i64*         ; [#uses = 1]
  store i64 %.len.i, i64* %7, align 8
  %8 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 2, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr.i, i8** %8, align 8
  %9 = bitcast %nest.main* %.frame to %object.Object** ; [#uses = 1]
  store %object.Object* %.newclass_gc_alloc, %object.Object** %9, align 8
  %10 = tail call i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %.newclass_gc) #1 ; [#uses = 2]
  %.not = icmp eq i32 %10, 0                      ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %0
  %11 = bitcast %nest.main* %.frame to i8*        ; [#uses = 6]
  %12 = bitcast %std.stdio.File* %__tmpfordtor204.i to i8* ; [#uses = 2]
  %13 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %14 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %15 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 1, i32 0 ; [#uses = 1, type = i64*]
  %16 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 1, i32 1 ; [#uses = 1, type = i32**]
  %17 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 2, i32 0 ; [#uses = 1, type = i64*]
  %18 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 2, i32 1 ; [#uses = 1, type = i32**]
  %19 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 1 ; [#uses = 2, type = { i64, i32* }*]
  %.elt = getelementptr { i64, i32* }, { i64, i32* }* %19, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.elt76 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 1, i32 1 ; [#uses = 2, type = i32**]
  %20 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 2 ; [#uses = 2, type = { i64, i32* }*]
  %.elt78 = getelementptr { i64, i32* }, { i64, i32* }* %20, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.elt80 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 2, i32 1 ; [#uses = 1, type = i32**]
  %.elt82 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.elt84 = getelementptr inbounds [3 x { i64, i32* }], [3 x { i64, i32* }]* %.nongc_mem110, i64 0, i64 0, i32 1 ; [#uses = 2, type = i32**]
  store i64 9223372036854775807, i64* %res, align 8
  %21 = call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ak6__initZ to %object.TypeInfo*), i64 3) #8 ; [#uses = 4]
  %.len.i.i.i116 = extractvalue { i64, i8* } %21, 0 ; [#uses = 2]
  %exitcond.not.i117 = icmp eq i64 %.len.i.i.i116, 0 ; [#uses = 1]
  br i1 %exitcond.not.i117, label %bounds.fail.i, label %bounds.ok.i.preheader

bounds.ok.i.preheader:                            ; preds = %forbody.lr.ph
  %.ptr.i.i.i115 = extractvalue { i64, i8* } %21, 1 ; [#uses = 1]
  br label %bounds.ok.i

bounds.ok.i:                                      ; preds = %bounds.ok.i.preheader, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge
  %.in = phi i8* [ %.ptr.i.i.i, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ %.ptr.i.i.i115, %bounds.ok.i.preheader ] ; [#uses = 3, type = i8*]
  %.len.i.i.i120 = phi i64 [ %.len.i.i.i, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ %.len.i.i.i116, %bounds.ok.i.preheader ] ; [#uses = 2, type = i64]
  %22 = phi { i64, i8* } [ %29, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ %21, %bounds.ok.i.preheader ] ; [#uses = 2, type = { i64, i8* }]
  %__key177.0101118 = phi i32 [ %28, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ 0, %bounds.ok.i.preheader ] ; [#uses = 1, type = i32]
  %23 = phi %source.InputReader* [ %.pre, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ %.newclass_gc, %bounds.ok.i.preheader ] ; [#uses = 3, type = %source.InputReader*]
  %24 = bitcast i8* %.in to i32*                  ; [#uses = 2]
  %25 = call i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %23) #0 ; [#uses = 1]
  store i32 %25, i32* %24, align 4
  %exitcond.not.i.1 = icmp eq i64 %.len.i.i.i120, 1 ; [#uses = 1]
  br i1 %exitcond.not.i.1, label %bounds.fail.i, label %bounds.ok.i.1

bounds.fail.i:                                    ; preds = %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge, %bounds.ok.i, %bounds.ok.i.1, %forbody.lr.ph
  %.lcssa = phi { i64, i8* } [ %21, %forbody.lr.ph ], [ %29, %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge ], [ %22, %bounds.ok.i ], [ %22, %bounds.ok.i.1 ] ; [#uses = 1, type = { i64, i8* }]
  %.len.i.i.i.le = extractvalue { i64, i8* } %.lcssa, 0 ; [#uses = 2]
  call void @_d_arraybounds_index({ i64, i8* } { i64 60, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.1, i32 0, i32 0) }, i32 99, i64 %.len.i.i.i.le, i64 %.len.i.i.i.le) #5
  unreachable

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

_D3std5stdio__T7writelnTlZQlFNflZv.exit:          ; preds = %bounds.ok10.2
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor204.i) #1
  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %12)
  %28 = add nuw i32 %__key177.0101118, 1          ; [#uses = 2]
  %exitcond.not = icmp eq i32 %28, %10            ; [#uses = 1]
  br i1 %exitcond.not, label %endfor, label %_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge

_D3std5stdio__T7writelnTlZQlFNflZv.exit.forbody_crit_edge: ; preds = %_D3std5stdio__T7writelnTlZQlFNflZv.exit
  %.pre = load %source.InputReader*, %source.InputReader** %r, align 8 ; [#uses = 1]
  store i64 9223372036854775807, i64* %res, align 8
  %29 = call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ak6__initZ to %object.TypeInfo*), i64 3) #8 ; [#uses = 4]
  %.ptr.i.i.i = extractvalue { i64, i8* } %29, 1  ; [#uses = 1]
  %.len.i.i.i = extractvalue { i64, i8* } %29, 0  ; [#uses = 2]
  %exitcond.not.i = icmp eq i64 %.len.i.i.i, 0    ; [#uses = 1]
  br i1 %exitcond.not.i, label %bounds.fail.i, label %bounds.ok.i

endfor:                                           ; preds = %_D3std5stdio__T7writelnTlZQlFNflZv.exit, %0
  ret i32 0

bounds.ok.i.1:                                    ; preds = %bounds.ok.i
  %30 = getelementptr inbounds i8, i8* %.in, i64 4 ; [#uses = 1, type = i8*]
  %31 = bitcast i8* %30 to i32*                   ; [#uses = 2]
  %32 = call i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %23) #0 ; [#uses = 1]
  store i32 %32, i32* %31, align 4
  %exitcond.not.i.2 = icmp eq i64 %.len.i.i.i120, 2 ; [#uses = 1]
  br i1 %exitcond.not.i.2, label %bounds.fail.i, label %bounds.ok10.2

bounds.ok10.2:                                    ; preds = %bounds.ok.i.1
  %33 = getelementptr inbounds i8, i8* %.in, i64 8 ; [#uses = 1, type = i8*]
  %34 = bitcast i8* %33 to i32*                   ; [#uses = 2]
  %35 = call i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %23) #0 ; [#uses = 1]
  store i32 %35, i32* %34, align 4
  %36 = load i32, i32* %24, align 4               ; [#uses = 1]
  %37 = call { i64, i32* } @_D6source4mainFZ2raMFiZAi(i8* nonnull %11, i32 %36) #0 ; [#uses = 2]
  %.ptr13 = extractvalue { i64, i32* } %37, 1     ; [#uses = 1]
  %.len14 = extractvalue { i64, i32* } %37, 0     ; [#uses = 1]
  store i64 %.len14, i64* %13, align 8
  store i32* %.ptr13, i32** %14, align 8
  %38 = load i32, i32* %31, align 4               ; [#uses = 1]
  %39 = call { i64, i32* } @_D6source4mainFZ2raMFiZAi(i8* nonnull %11, i32 %38) #0 ; [#uses = 2]
  %.ptr13.1 = extractvalue { i64, i32* } %39, 1   ; [#uses = 1]
  %.len14.1 = extractvalue { i64, i32* } %39, 0   ; [#uses = 1]
  store i64 %.len14.1, i64* %15, align 8
  store i32* %.ptr13.1, i32** %16, align 8
  %40 = load i32, i32* %34, align 4               ; [#uses = 1]
  %41 = call { i64, i32* } @_D6source4mainFZ2raMFiZAi(i8* nonnull %11, i32 %40) #0 ; [#uses = 3]
  %.ptr13.2 = extractvalue { i64, i32* } %41, 1   ; [#uses = 1]
  %.len14.2 = extractvalue { i64, i32* } %41, 0   ; [#uses = 1]
  store i64 %.len14.2, i64* %17, align 8
  store i32* %.ptr13.2, i32** %18, align 8
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %42 = insertvalue { i64, i32* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.unpack77 = load i32*, i32** %.elt76, align 8  ; [#uses = 1]
  %43 = insertvalue { i64, i32* } %42, i32* %.unpack77, 1 ; [#uses = 1]
  call void @_D6source4mainFZ1fMFNaNbNiNfIAiIQdIQgZv(i8* nonnull %11, { i64, i32* } %41, { i64, i32* } %43, { i64, i32* }* nonnull byval align 8 %.nongc_mem110.sub) #0
  %.unpack83 = load i64, i64* %.elt82, align 8    ; [#uses = 1]
  %44 = insertvalue { i64, i32* } undef, i64 %.unpack83, 0 ; [#uses = 1]
  %.unpack85 = load i32*, i32** %.elt84, align 8  ; [#uses = 1]
  %45 = insertvalue { i64, i32* } %44, i32* %.unpack85, 1 ; [#uses = 1]
  %.unpack87 = load i64, i64* %.elt78, align 8    ; [#uses = 1]
  %46 = insertvalue { i64, i32* } undef, i64 %.unpack87, 0 ; [#uses = 1]
  %.unpack89 = load i32*, i32** %.elt80, align 8  ; [#uses = 1]
  %47 = insertvalue { i64, i32* } %46, i32* %.unpack89, 1 ; [#uses = 1]
  call void @_D6source4mainFZ1fMFNaNbNiNfIAiIQdIQgZv(i8* nonnull %11, { i64, i32* } %47, { i64, i32* } %45, { i64, i32* }* nonnull byval align 8 %19) #0
  %.unpack91 = load i64, i64* %.elt82, align 8    ; [#uses = 1]
  %48 = insertvalue { i64, i32* } undef, i64 %.unpack91, 0 ; [#uses = 1]
  %.unpack93 = load i32*, i32** %.elt84, align 8  ; [#uses = 1]
  %49 = insertvalue { i64, i32* } %48, i32* %.unpack93, 1 ; [#uses = 1]
  %.unpack95 = load i64, i64* %.elt, align 8      ; [#uses = 1]
  %50 = insertvalue { i64, i32* } undef, i64 %.unpack95, 0 ; [#uses = 1]
  %.unpack97 = load i32*, i32** %.elt76, align 8  ; [#uses = 1]
  %51 = insertvalue { i64, i32* } %50, i32* %.unpack97, 1 ; [#uses = 1]
  call void @_D6source4mainFZ1fMFNaNbNiNfIAiIQdIQgZv(i8* nonnull %11, { i64, i32* } %51, { i64, i32* } %49, { i64, i32* }* nonnull byval align 8 %20) #0
  %52 = load i64, i64* %res, align 8              ; [#uses = 1]
  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %12)
  call void @_D3std5stdio13trustedStdoutFNdNeZSQBgQBf4File(%std.stdio.File* noalias nonnull sret align 8 %__tmpfordtor204.i) #1
  invoke void @_D3std5stdio4File__T5writeTlTaZQlMFNflaZv(%std.stdio.File* nonnull %__tmpfordtor204.i, i8 zeroext 10, i64 %52) #1
          to label %_D3std5stdio__T7writelnTlZQlFNflZv.exit unwind label %eh.resume.i
}

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

; [#uses = 5]
; Function Attrs: uwtable
define weak_odr i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 7, type = i64*]
  %.elt8.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 7, type = i8**]
  %1 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 4 ; [#uses = 4, type = i8*]
  %.elt.i.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 2, type = i64*]
  %.elt9.i.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 2, type = i8**]
  %.unpack.pre.i = load i64, i64* %.elt.i, align 8 ; [#uses = 1]
  %.unpack9.pre.i = load i8*, i8** %.elt8.i, align 8 ; [#uses = 1]
  br label %forcond.i

forcond.i:                                        ; preds = %endif.i.i, %0
  %.unpack9.i = phi i8* [ %.ptr.i.i, %endif.i.i ], [ %.unpack9.pre.i, %0 ] ; [#uses = 3, type = i8*]
  %.unpack.i = phi i64 [ %.len.i.i, %endif.i.i ], [ %.unpack.pre.i, %0 ] ; [#uses = 3, type = i64]
  %.not.i20.i.i = icmp eq i64 %.unpack.i, 0       ; [#uses = 1]
  br i1 %.not.i20.i.i, label %endif.i, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i: ; preds = %forcond.i
  %scevgep.i.i = getelementptr i8, i8* %.unpack9.i, i64 %.unpack.i ; [#uses = 1, type = i8*]
  br label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i: ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i
  %haystack.sroa.0.022.i.i = phi i64 [ %.unpack.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i ], [ %3, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 3, type = i64]
  %.unpack4.i = phi i8* [ %.unpack9.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i ], [ %lowerbound.i.i.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 5, type = i8*]
  %2 = load i8, i8* %.unpack4.i, align 1          ; [#uses = 1]
  %.not.i.i = icmp ult i8 %2, 48                  ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, label %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i
  %lowerbound.i.i.i = getelementptr inbounds i8, i8* %.unpack4.i, i64 1 ; [#uses = 1, type = i8*]
  %3 = add i64 %haystack.sroa.0.022.i.i, -1       ; [#uses = 2]
  %.not.i.i.i = icmp eq i64 %3, 0                 ; [#uses = 1]
  br i1 %.not.i.i.i, label %endif.i, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i

endif.i:                                          ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, %forcond.i
  %haystack.sroa.6.0.lcssa.i.ph.i = phi i8* [ %.unpack9.i, %forcond.i ], [ %scevgep.i.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 1, type = i8*]
  store i64 0, i64* %.elt.i, align 8
  store i8* %haystack.sroa.6.0.lcssa.i.ph.i, i8** %.elt8.i, align 8
  %4 = load i8, i8* %1, align 1, !range !15       ; [#uses = 1]
  %.not.i10.i = icmp eq i8 %4, 0                  ; [#uses = 1]
  br i1 %.not.i10.i, label %endif.i.i, label %if

endif.i.i:                                        ; preds = %endif.i
  %5 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i.i = load i64, i64* %.elt.i.i, align 8 ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack.i.i, 0 ; [#uses = 1]
  %.unpack10.i.i = load i8*, i8** %.elt9.i.i, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack10.i.i, 1 ; [#uses = 1]
  %8 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %5, { i64, i8* } %7) #1 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %8, 1     ; [#uses = 2]
  %.len.i.i = extractvalue { i64, i8* } %8, 0     ; [#uses = 3]
  store i64 %.len.i.i, i64* %.elt.i, align 8
  store i8* %.ptr.i.i, i8** %.elt8.i, align 8
  %.not.i.i11.i = icmp eq i64 %.len.i.i, 0        ; [#uses = 1]
  br i1 %.not.i.i11.i, label %if1.i.i, label %forcond.i

if1.i.i:                                          ; preds = %endif.i.i
  store i8 1, i8* %1, align 1
  br label %if

if:                                               ; preds = %endif.i, %if.i, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit, %if1.i.i20, %if1.i.i
  %merge = phi i32 [ 0, %if1.i.i ], [ %res.0, %if1.i.i20 ], [ %res.0, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit ], [ %res.0, %if.i ], [ 0, %endif.i ] ; [#uses = 1, type = i32]
  ret i32 %merge

_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i
  store i64 %haystack.sroa.0.022.i.i, i64* %.elt.i, align 8
  store i8* %.unpack4.i, i8** %.elt8.i, align 8
  %9 = load i8, i8* %.unpack4.i, align 1          ; [#uses = 1]
  %lowerbound.i.i = getelementptr inbounds i8, i8* %.unpack4.i, i64 1 ; [#uses = 2, type = i8*]
  %10 = add i64 %haystack.sroa.0.022.i.i, -1      ; [#uses = 2]
  store i64 %10, i64* %.elt.i, align 8
  store i8* %lowerbound.i.i, i8** %.elt8.i, align 8
  %11 = zext i8 %9 to i32                         ; [#uses = 1]
  %12 = add nsw i32 %11, -48                      ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %endif2, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit
  %.unpack922.pre.i = phi i8* [ %lowerbound.i.i21, %endif2 ], [ %lowerbound.i.i, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 1, type = i8*]
  %.len.i.i12 = phi i64 [ %19, %endif2 ], [ %10, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 2, type = i64]
  %res.0 = phi i32 [ %24, %endif2 ], [ %12, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 4, type = i32]
  %.not.i.i13 = icmp eq i64 %.len.i.i12, 0        ; [#uses = 1]
  br i1 %.not.i.i13, label %if.i, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit

if.i:                                             ; preds = %forcond
  %13 = load i8, i8* %1, align 1, !range !15      ; [#uses = 1]
  %.not.i12.i = icmp eq i8 %13, 0                 ; [#uses = 1]
  br i1 %.not.i12.i, label %endif.i.i19, label %if

endif.i.i19:                                      ; preds = %if.i
  %14 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i.i15 = load i64, i64* %.elt.i.i, align 8 ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %.unpack.i.i15, 0 ; [#uses = 1]
  %.unpack10.i.i17 = load i8*, i8** %.elt9.i.i, align 8 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %.unpack10.i.i17, 1 ; [#uses = 1]
  %17 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %14, { i64, i8* } %16) #1 ; [#uses = 2]
  %.ptr.i13.i = extractvalue { i64, i8* } %17, 1  ; [#uses = 2]
  %.len.i14.i = extractvalue { i64, i8* } %17, 0  ; [#uses = 3]
  store i64 %.len.i14.i, i64* %.elt.i, align 8
  store i8* %.ptr.i13.i, i8** %.elt8.i, align 8
  %.not.i.i.i18 = icmp eq i64 %.len.i14.i, 0      ; [#uses = 1]
  br i1 %.not.i.i.i18, label %if1.i.i20, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit

if1.i.i20:                                        ; preds = %endif.i.i19
  store i8 1, i8* %1, align 1
  br label %if

_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit: ; preds = %forcond, %endif.i.i19
  %.unpack922.i = phi i8* [ %.ptr.i13.i, %endif.i.i19 ], [ %.unpack922.pre.i, %forcond ] ; [#uses = 2, type = i8*]
  %.unpack21.i = phi i64 [ %.len.i14.i, %endif.i.i19 ], [ %.len.i.i12, %forcond ] ; [#uses = 1, type = i64]
  %18 = load i8, i8* %.unpack922.i, align 1       ; [#uses = 2]
  %lowerbound.i.i21 = getelementptr inbounds i8, i8* %.unpack922.i, i64 1 ; [#uses = 2, type = i8*]
  %19 = add i64 %.unpack21.i, -1                  ; [#uses = 2]
  store i64 %19, i64* %.elt.i, align 8
  store i8* %lowerbound.i.i21, i8** %.elt8.i, align 8
  %.off = add i8 %18, -48                         ; [#uses = 1]
  %20 = icmp ugt i8 %.off, 9                      ; [#uses = 1]
  br i1 %20, label %if, label %endif2

endif2:                                           ; preds = %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit
  %21 = zext i8 %18 to i32                        ; [#uses = 1]
  %22 = mul i32 %res.0, 10                        ; [#uses = 1]
  %23 = add i32 %22, -48                          ; [#uses = 1]
  %24 = add i32 %23, %21                          ; [#uses = 1]
  br label %forcond
}

; [#uses = 3]
; Function Attrs: uwtable
define { i64, i32* } @_D6source4mainFZ2raMFiZAi(i8* nocapture nonnull readonly %.nest_arg, i32 %n_arg) local_unnamed_addr #0 {
  %r = bitcast i8* %.nest_arg to %source.InputReader** ; [#uses = 1]
  %1 = load %source.InputReader*, %source.InputReader** %r, align 8 ; [#uses = 1]
  %2 = sext i32 %n_arg to i64                     ; [#uses = 1]
  %3 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %2) #8 ; [#uses = 2]
  %.ptr.i.i.i = extractvalue { i64, i8* } %3, 1   ; [#uses = 1]
  %.len.i.i.i = extractvalue { i64, i8* } %3, 0   ; [#uses = 7]
  %4 = bitcast i8* %.ptr.i.i.i to i32*            ; [#uses = 4]
  %5 = icmp sgt i32 %n_arg, 0                     ; [#uses = 1]
  br i1 %5, label %forbody.preheader.i, label %_D6source11InputReader__T5nextATiZQjMFIiZAi.exit

forbody.preheader.i:                              ; preds = %0
  %wide.trip.count.i = zext i32 %n_arg to i64     ; [#uses = 1]
  br label %forbody.i

forbody.i:                                        ; preds = %bounds.ok.i, %forbody.preheader.i
  %indvars.iv.i = phi i64 [ 0, %forbody.preheader.i ], [ %indvars.iv.next.i, %bounds.ok.i ] ; [#uses = 3, type = i64]
  %exitcond.not.i = icmp eq i64 %indvars.iv.i, %.len.i.i.i ; [#uses = 1]
  br i1 %exitcond.not.i, label %bounds.fail.i, label %bounds.ok.i

bounds.ok.i:                                      ; preds = %forbody.i
  %6 = getelementptr inbounds i32, i32* %4, i64 %indvars.iv.i ; [#uses = 1, type = i32*]
  %7 = tail call i32 @_D6source11InputReader__T4nextTiZQiMFZi(%source.InputReader* nonnull %1) #1 ; [#uses = 1]
  store i32 %7, i32* %6, align 4
  %indvars.iv.next.i = add nuw nsw i64 %indvars.iv.i, 1 ; [#uses = 2]
  %exitcond16.not.i = icmp eq i64 %indvars.iv.next.i, %wide.trip.count.i ; [#uses = 1]
  br i1 %exitcond16.not.i, label %_D6source11InputReader__T5nextATiZQjMFIiZAi.exit, label %forbody.i

bounds.fail.i:                                    ; preds = %forbody.i
  %8 = and i64 %.len.i.i.i, 4294967295            ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 60, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.1, i32 0, i32 0) }, i32 99, i64 %8, i64 %.len.i.i.i) #5
  unreachable

_D6source11InputReader__T5nextATiZQjMFIiZAi.exit: ; preds = %bounds.ok.i, %0
  %.fca.0.insert.i.i.i = insertvalue { i64, i32* } undef, i64 %.len.i.i.i, 0 ; [#uses = 1]
  %.fca.1.insert8.i.i.i = insertvalue { i64, i32* } %.fca.0.insert.i.i.i, i32* %4, 1 ; [#uses = 2]
  tail call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDhFNaNbNiNfQpmZv(i64 %.len.i.i.i, { i64, i32* } %.fca.1.insert8.i.i.i) #1
  %.not.i.i.i = icmp eq i64 %.len.i.i.i, 0        ; [#uses = 1]
  br i1 %.not.i.i.i, label %_D3std9algorithm7sorting__T4sortVAyaa5_61203c2062VEQBxQBw8mutation12SwapStrategyi0TAiZQChFNaNbNiNfQpZSQDw5range__T11SortedRangeTQBtVQDva5_61203c2062VEQFsQBw18SortedRangeOptionsi0ZQCn.exit, label %endif.i.i

endif.i.i:                                        ; preds = %_D6source11InputReader__T5nextATiZQjMFIiZAi.exit
  %9 = add i64 %.len.i.i.i, -1                    ; [#uses = 1]
  br label %forcond.i.i

forcond.i.i:                                      ; preds = %bounds.ok4.i.i, %endif.i.i
  %__key173.0.i.i = phi i64 [ 0, %endif.i.i ], [ %10, %bounds.ok4.i.i ] ; [#uses = 3, type = i64]
  %exitcond.not.i.i = icmp eq i64 %__key173.0.i.i, %9 ; [#uses = 1]
  br i1 %exitcond.not.i.i, label %_D3std9algorithm7sorting__T4sortVAyaa5_61203c2062VEQBxQBw8mutation12SwapStrategyi0TAiZQChFNaNbNiNfQpZSQDw5range__T11SortedRangeTQBtVQDva5_61203c2062VEQFsQBw18SortedRangeOptionsi0ZQCn.exit, label %bounds.ok4.i.i

bounds.ok4.i.i:                                   ; preds = %forcond.i.i
  %10 = add nuw i64 %__key173.0.i.i, 1            ; [#uses = 2]
  %11 = getelementptr inbounds i32, i32* %4, i64 %10 ; [#uses = 1, type = i32*]
  %12 = getelementptr inbounds i32, i32* %4, i64 %__key173.0.i.i ; [#uses = 1, type = i32*]
  %13 = load i32, i32* %11, align 4               ; [#uses = 1]
  %14 = load i32, i32* %12, align 4               ; [#uses = 1]
  %15 = icmp slt i32 %13, %14                     ; [#uses = 1]
  br i1 %15, label %assertFailed.i, label %forcond.i.i

assertFailed.i:                                   ; preds = %bounds.ok4.i.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 34, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.12, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1949) #5
  unreachable

_D3std9algorithm7sorting__T4sortVAyaa5_61203c2062VEQBxQBw8mutation12SwapStrategyi0TAiZQChFNaNbNiNfQpZSQDw5range__T11SortedRangeTQBtVQDva5_61203c2062VEQFsQBw18SortedRangeOptionsi0ZQCn.exit: ; preds = %forcond.i.i, %_D6source11InputReader__T5nextATiZQjMFIiZAi.exit
  ret { i64, i32* } %.fca.1.insert8.i.i.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D6source11InputReader__T5nextATiZQjMFIiZAi(%source.InputReader* nonnull %.this_arg, i32 %n_arg) local_unnamed_addr #0 {
  %1 = sext i32 %n_arg to i64                     ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %1) #8 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %2, 1     ; [#uses = 1]
  %.len.i.i = extractvalue { i64, i8* } %2, 0     ; [#uses = 4]
  %3 = bitcast i8* %.ptr.i.i to i32*              ; [#uses = 2]
  %4 = icmp sgt i32 %n_arg, 0                     ; [#uses = 1]
  br i1 %4, label %forbody.preheader, label %endfor

forbody.preheader:                                ; preds = %0
  %wide.trip.count = zext i32 %n_arg to i64       ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %bounds.ok, %forbody.preheader
  %indvars.iv = phi i64 [ 0, %forbody.preheader ], [ %indvars.iv.next, %bounds.ok ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %indvars.iv, %.len.i.i ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody
  %5 = getelementptr inbounds i32, i32* %3, i64 %indvars.iv ; [#uses = 1, type = i32*]
  %6 = tail call i32 @_D6source11InputReader__T4nextTiZQiMFZi(%source.InputReader* nonnull %.this_arg) #1 ; [#uses = 1]
  store i32 %6, i32* %5, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 2]
  %exitcond16.not = icmp eq i64 %indvars.iv.next, %wide.trip.count ; [#uses = 1]
  br i1 %exitcond16.not, label %endfor, label %forbody

bounds.fail:                                      ; preds = %forbody
  %7 = and i64 %.len.i.i, 4294967295              ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 60, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.1, i32 0, i32 0) }, i32 99, i64 %7, i64 %.len.i.i) #5
  unreachable

endfor:                                           ; preds = %bounds.ok, %0
  %.fca.0.insert.i.i = insertvalue { i64, i32* } undef, i64 %.len.i.i, 0 ; [#uses = 1]
  %.fca.1.insert8.i.i = insertvalue { i64, i32* } %.fca.0.insert.i.i, i32* %3, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8.i.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std9algorithm7sorting__T4sortVAyaa5_61203c2062VEQBxQBw8mutation12SwapStrategyi0TAiZQChFNaNbNiNfQpZSQDw5range__T11SortedRangeTQBtVQDva5_61203c2062VEQFsQBw18SortedRangeOptionsi0ZQCn({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 4]
  tail call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDhFNaNbNiNfQpmZv(i64 %r_arg.fca.0.extract, { i64, i32* } %r_arg) #1
  %r_arg.fca.1.extract.i = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 3]
  %.not.i.i = icmp eq i64 %r_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %.not.i.i, label %assertPassed, label %endif.i

endif.i:                                          ; preds = %0
  %1 = add i64 %r_arg.fca.0.extract, -1           ; [#uses = 1]
  br label %forcond.i

forcond.i:                                        ; preds = %bounds.ok4.i, %endif.i
  %__key173.0.i = phi i64 [ 0, %endif.i ], [ %2, %bounds.ok4.i ] ; [#uses = 3, type = i64]
  %exitcond.not.i = icmp eq i64 %__key173.0.i, %1 ; [#uses = 1]
  br i1 %exitcond.not.i, label %assertPassed, label %bounds.ok4.i

bounds.ok4.i:                                     ; preds = %forcond.i
  %2 = add nuw i64 %__key173.0.i, 1               ; [#uses = 2]
  %3 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract.i, i64 %2 ; [#uses = 1, type = i32*]
  %4 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract.i, i64 %__key173.0.i ; [#uses = 1, type = i32*]
  %5 = load i32, i32* %3, align 4                 ; [#uses = 1]
  %6 = load i32, i32* %4, align 4                 ; [#uses = 1]
  %7 = icmp slt i32 %5, %6                        ; [#uses = 1]
  br i1 %7, label %assertFailed, label %forcond.i

assertPassed:                                     ; preds = %forcond.i, %0
  %.fca.0.0.insert.i = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %r_arg.fca.0.extract, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert.i = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert.i, i32* %r_arg.fca.1.extract.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert.i

assertFailed:                                     ; preds = %bounds.ok4.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 34, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.12, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1949) #5
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D6source11InputReader__T5nextATkZQjMFIiZAk(%source.InputReader* nonnull %.this_arg, i32 %n_arg) local_unnamed_addr #0 {
  %1 = sext i32 %n_arg to i64                     ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ak6__initZ to %object.TypeInfo*), i64 %1) #8 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %2, 1     ; [#uses = 1]
  %.len.i.i = extractvalue { i64, i8* } %2, 0     ; [#uses = 4]
  %3 = bitcast i8* %.ptr.i.i to i32*              ; [#uses = 2]
  %4 = icmp sgt i32 %n_arg, 0                     ; [#uses = 1]
  br i1 %4, label %forbody.preheader, label %endfor

forbody.preheader:                                ; preds = %0
  %wide.trip.count = zext i32 %n_arg to i64       ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %bounds.ok, %forbody.preheader
  %indvars.iv = phi i64 [ 0, %forbody.preheader ], [ %indvars.iv.next, %bounds.ok ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %indvars.iv, %.len.i.i ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody
  %5 = getelementptr inbounds i32, i32* %3, i64 %indvars.iv ; [#uses = 1, type = i32*]
  %6 = tail call i32 @_D6source11InputReader__T4nextTkZQiMFZk(%source.InputReader* nonnull %.this_arg) #0 ; [#uses = 1]
  store i32 %6, i32* %5, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 2]
  %exitcond16.not = icmp eq i64 %indvars.iv.next, %wide.trip.count ; [#uses = 1]
  br i1 %exitcond16.not, label %endfor, label %forbody

bounds.fail:                                      ; preds = %forbody
  %7 = and i64 %.len.i.i, 4294967295              ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 60, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.1, i32 0, i32 0) }, i32 99, i64 %7, i64 %.len.i.i) #5
  unreachable

endfor:                                           ; preds = %bounds.ok, %0
  %.fca.0.insert.i.i = insertvalue { i64, i32* } undef, i64 %.len.i.i, 0 ; [#uses = 1]
  %.fca.1.insert8.i.i = insertvalue { i64, i32* } %.fca.0.insert.i.i, i32* %3, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8.i.i
}

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

; [#uses = 0]
; Function Attrs: nofree norecurse nounwind uwtable
define void @_D6source4mainFZ5checkMFNaNbNiNflllZv(i8* nocapture nonnull %.nest_arg, i64 %w_arg, i64 %v_arg, i64 %u_arg) local_unnamed_addr #6 {
  %1 = sub i64 %u_arg, %v_arg                     ; [#uses = 2]
  %2 = mul i64 %1, %1                             ; [#uses = 1]
  %3 = sub i64 %u_arg, %w_arg                     ; [#uses = 2]
  %4 = mul i64 %3, %3                             ; [#uses = 1]
  %5 = sub i64 %v_arg, %w_arg                     ; [#uses = 2]
  %6 = mul i64 %5, %5                             ; [#uses = 1]
  %7 = add i64 %4, %6                             ; [#uses = 1]
  %8 = add i64 %7, %2                             ; [#uses = 2]
  %res = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %9 = bitcast i8* %res to i64*                   ; [#uses = 2]
  %10 = load i64, i64* %9, align 8                ; [#uses = 1]
  %11 = icmp sgt i64 %10, %8                      ; [#uses = 1]
  br i1 %11, label %if, label %endif

if:                                               ; preds = %0
  store i64 %8, i64* %9, align 8
  br label %endif

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

; [#uses = 3]
; Function Attrs: uwtable
define void @_D6source4mainFZ1fMFNaNbNiNfIAiIQdIQgZv(i8* nonnull %.nest_arg, { i64, i32* } %z_arg, { i64, i32* } %y_arg, { i64, i32* }* nocapture readonly byval align 8 %x) local_unnamed_addr #0 {
  %y_arg.fca.0.extract = extractvalue { i64, i32* } %y_arg, 0 ; [#uses = 5]
  %y_arg.fca.1.extract = extractvalue { i64, i32* } %y_arg, 1 ; [#uses = 6]
  %z_arg.fca.0.extract = extractvalue { i64, i32* } %z_arg, 0 ; [#uses = 7]
  %z_arg.fca.1.extract = extractvalue { i64, i32* } %z_arg, 1 ; [#uses = 5]
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %x, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %.not130 = icmp eq i64 %.len, 0                 ; [#uses = 1]
  br i1 %.not130, label %endfor, label %bounds.ok.lr.ph

bounds.ok.lr.ph:                                  ; preds = %0
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %x, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr = load i32*, i32** %2, align 8            ; [#uses = 1]
  %res.i.i = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %3 = bitcast i8* %res.i.i to i64*               ; [#uses = 8]
  br label %bounds.ok

bounds.ok:                                        ; preds = %forinc, %bounds.ok.lr.ph
  %j.0129 = phi i64 [ 0, %bounds.ok.lr.ph ], [ %j.1.lcssa, %forinc ] ; [#uses = 5, type = i64]
  %k.0128 = phi i64 [ 0, %bounds.ok.lr.ph ], [ %k.1116, %forinc ] ; [#uses = 5, type = i64]
  %__key185.0127 = phi i64 [ 0, %bounds.ok.lr.ph ], [ %99, %forinc ] ; [#uses = 2, type = i64]
  %4 = getelementptr inbounds i32, i32* %.ptr, i64 %__key185.0127 ; [#uses = 1, type = i32*]
  %5 = load i32, i32* %4, align 4                 ; [#uses = 8]
  %6 = icmp ult i64 %j.0129, %y_arg.fca.0.extract ; [#uses = 1]
  br i1 %6, label %bounds.ok11.preheader, label %endfor7

bounds.ok11.preheader:                            ; preds = %bounds.ok
  %7 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %j.0129 ; [#uses = 1, type = i32*]
  %8 = load i32, i32* %7, align 4                 ; [#uses = 1]
  %9 = icmp slt i32 %8, %5                        ; [#uses = 1]
  br i1 %9, label %forbody5, label %endfor7

bounds.ok11:                                      ; preds = %forbody5
  %10 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %13 ; [#uses = 1, type = i32*]
  %11 = load i32, i32* %10, align 4               ; [#uses = 1]
  %12 = icmp slt i32 %11, %5                      ; [#uses = 1]
  br i1 %12, label %forbody5, label %endfor7.loopexit

forbody5:                                         ; preds = %bounds.ok11.preheader, %bounds.ok11
  %j.1120150 = phi i64 [ %13, %bounds.ok11 ], [ %j.0129, %bounds.ok11.preheader ] ; [#uses = 1, type = i64]
  %13 = add i64 %j.1120150, 1                     ; [#uses = 5]
  %exitcond.not = icmp eq i64 %13, %y_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %endfor7.loopexit, label %bounds.ok11

endfor7.loopexit:                                 ; preds = %bounds.ok11, %forbody5
  %j.1.lcssa.ph = phi i64 [ %13, %bounds.ok11 ], [ %y_arg.fca.0.extract, %forbody5 ] ; [#uses = 1, type = i64]
  %14 = icmp ult i64 %13, %y_arg.fca.0.extract    ; [#uses = 1]
  br label %endfor7

endfor7:                                          ; preds = %endfor7.loopexit, %bounds.ok11.preheader, %bounds.ok
  %j.1.lcssa = phi i64 [ %j.0129, %bounds.ok ], [ %j.0129, %bounds.ok11.preheader ], [ %j.1.lcssa.ph, %endfor7.loopexit ] ; [#uses = 5, type = i64]
  %.lcssa = phi i1 [ false, %bounds.ok ], [ true, %bounds.ok11.preheader ], [ %14, %endfor7.loopexit ] ; [#uses = 2, type = i1]
  %15 = icmp ult i64 %k.0128, %z_arg.fca.0.extract ; [#uses = 1]
  br i1 %15, label %bounds.ok23.preheader, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit

bounds.ok23.preheader:                            ; preds = %endfor7
  %16 = getelementptr inbounds i32, i32* %z_arg.fca.1.extract, i64 %k.0128 ; [#uses = 1, type = i32*]
  %17 = load i32, i32* %16, align 4               ; [#uses = 2]
  %18 = icmp slt i32 %17, %5                      ; [#uses = 1]
  br i1 %18, label %forbody15, label %endfor17

bounds.ok23:                                      ; preds = %forbody15
  %19 = getelementptr inbounds i32, i32* %z_arg.fca.1.extract, i64 %22 ; [#uses = 1, type = i32*]
  %20 = load i32, i32* %19, align 4               ; [#uses = 2]
  %21 = icmp slt i32 %20, %5                      ; [#uses = 1]
  br i1 %21, label %forbody15, label %endfor17.loopexit

forbody15:                                        ; preds = %bounds.ok23.preheader, %bounds.ok23
  %k.1124154 = phi i64 [ %22, %bounds.ok23 ], [ %k.0128, %bounds.ok23.preheader ] ; [#uses = 1, type = i64]
  %22 = add i64 %k.1124154, 1                     ; [#uses = 6]
  %exitcond136.not = icmp eq i64 %22, %z_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond136.not, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.loopexit, label %bounds.ok23

endfor17.loopexit:                                ; preds = %bounds.ok23
  %23 = icmp ult i64 %22, %z_arg.fca.0.extract    ; [#uses = 1]
  br label %endfor17

endfor17:                                         ; preds = %endfor17.loopexit, %bounds.ok23.preheader
  %.lcssa147 = phi i1 [ true, %bounds.ok23.preheader ], [ %23, %endfor17.loopexit ] ; [#uses = 3, type = i1]
  %k.1124.lcssa = phi i64 [ %k.0128, %bounds.ok23.preheader ], [ %22, %endfor17.loopexit ] ; [#uses = 4, type = i64]
  %.lcssa144 = phi i32 [ %17, %bounds.ok23.preheader ], [ %20, %endfor17.loopexit ] ; [#uses = 1, type = i32]
  br i1 %.lcssa, label %if.i, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread

if.i:                                             ; preds = %endfor17
  %24 = sext i32 %5 to i64                        ; [#uses = 2]
  %25 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %j.1.lcssa ; [#uses = 1, type = i32*]
  %26 = load i32, i32* %25, align 4               ; [#uses = 1]
  %27 = sext i32 %26 to i64                       ; [#uses = 2]
  %28 = sext i32 %.lcssa144 to i64                ; [#uses = 2]
  %29 = sub nsw i64 %24, %27                      ; [#uses = 2]
  %30 = mul i64 %29, %29                          ; [#uses = 1]
  %31 = sub nsw i64 %24, %28                      ; [#uses = 2]
  %32 = mul i64 %31, %31                          ; [#uses = 1]
  %33 = sub nsw i64 %27, %28                      ; [#uses = 2]
  %34 = mul i64 %33, %33                          ; [#uses = 1]
  %35 = add i64 %34, %30                          ; [#uses = 1]
  %36 = add i64 %35, %32                          ; [#uses = 2]
  %37 = load i64, i64* %3, align 8                ; [#uses = 1]
  %38 = icmp sgt i64 %37, %36                     ; [#uses = 1]
  br i1 %38, label %if.i.i, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit

if.i.i:                                           ; preds = %if.i
  store i64 %36, i64* %3, align 8
  br label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit

_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.loopexit: ; preds = %forbody15
  %39 = icmp ult i64 %22, %z_arg.fca.0.extract    ; [#uses = 1]
  br label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit

_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit: ; preds = %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.loopexit, %endfor7, %if.i, %if.i.i
  %k.1117 = phi i64 [ %k.1124.lcssa, %if.i ], [ %k.1124.lcssa, %if.i.i ], [ %k.0128, %endfor7 ], [ %z_arg.fca.0.extract, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.loopexit ] ; [#uses = 5, type = i64]
  %40 = phi i1 [ %.lcssa147, %if.i ], [ %.lcssa147, %if.i.i ], [ false, %endfor7 ], [ %39, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.loopexit ] ; [#uses = 4, type = i1]
  %.not = icmp eq i64 %k.1117, 0                  ; [#uses = 1]
  br i1 %.not, label %endif, label %if

_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread: ; preds = %endfor17
  %.not108 = icmp eq i64 %k.1124.lcssa, 0         ; [#uses = 1]
  br label %endif

if:                                               ; preds = %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit
  %41 = add i64 %k.1117, -1                       ; [#uses = 2]
  %42 = icmp ugt i64 %z_arg.fca.0.extract, %41    ; [#uses = 1]
  %or.cond = and i1 %.lcssa, %42                  ; [#uses = 1]
  br i1 %or.cond, label %if.i92, label %endif

if.i92:                                           ; preds = %if
  %43 = sext i32 %5 to i64                        ; [#uses = 2]
  %44 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %j.1.lcssa ; [#uses = 1, type = i32*]
  %45 = load i32, i32* %44, align 4               ; [#uses = 1]
  %46 = sext i32 %45 to i64                       ; [#uses = 2]
  %47 = getelementptr inbounds i32, i32* %z_arg.fca.1.extract, i64 %41 ; [#uses = 1, type = i32*]
  %48 = load i32, i32* %47, align 4               ; [#uses = 1]
  %49 = sext i32 %48 to i64                       ; [#uses = 2]
  %50 = sub nsw i64 %43, %46                      ; [#uses = 2]
  %51 = mul i64 %50, %50                          ; [#uses = 1]
  %52 = sub nsw i64 %43, %49                      ; [#uses = 2]
  %53 = mul i64 %52, %52                          ; [#uses = 1]
  %54 = sub nsw i64 %46, %49                      ; [#uses = 2]
  %55 = mul i64 %54, %54                          ; [#uses = 1]
  %56 = add i64 %55, %51                          ; [#uses = 1]
  %57 = add i64 %56, %53                          ; [#uses = 2]
  %58 = load i64, i64* %3, align 8                ; [#uses = 1]
  %59 = icmp sgt i64 %58, %57                     ; [#uses = 1]
  br i1 %59, label %if.i.i93, label %endif

if.i.i93:                                         ; preds = %if.i92
  store i64 %57, i64* %3, align 8
  br label %endif

endif:                                            ; preds = %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread, %if.i.i93, %if.i92, %if, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit
  %k.1116 = phi i64 [ %k.1117, %if.i.i93 ], [ %k.1117, %if.i92 ], [ %k.1117, %if ], [ 0, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit ], [ %k.1124.lcssa, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread ] ; [#uses = 3, type = i64]
  %60 = phi i1 [ %40, %if.i.i93 ], [ %40, %if.i92 ], [ %40, %if ], [ %40, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit ], [ %.lcssa147, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread ] ; [#uses = 1, type = i1]
  %.not110 = phi i1 [ false, %if.i.i93 ], [ false, %if.i92 ], [ false, %if ], [ true, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit ], [ %.not108, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit.thread ] ; [#uses = 1, type = i1]
  %.not55 = icmp eq i64 %j.1.lcssa, 0             ; [#uses = 1]
  br i1 %.not55, label %forinc, label %if27

if27:                                             ; preds = %endif
  %61 = add i64 %j.1.lcssa, -1                    ; [#uses = 3]
  %62 = icmp ugt i64 %y_arg.fca.0.extract, %61    ; [#uses = 1]
  br i1 %62, label %andand.i73, label %forinc

andand.i73:                                       ; preds = %if27
  br i1 %60, label %if.i79, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81

if.i79:                                           ; preds = %andand.i73
  %63 = sext i32 %5 to i64                        ; [#uses = 2]
  %64 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %61 ; [#uses = 1, type = i32*]
  %65 = load i32, i32* %64, align 4               ; [#uses = 1]
  %66 = sext i32 %65 to i64                       ; [#uses = 2]
  %67 = getelementptr inbounds i32, i32* %z_arg.fca.1.extract, i64 %k.1116 ; [#uses = 1, type = i32*]
  %68 = load i32, i32* %67, align 4               ; [#uses = 1]
  %69 = sext i32 %68 to i64                       ; [#uses = 2]
  %70 = sub nsw i64 %63, %66                      ; [#uses = 2]
  %71 = mul i64 %70, %70                          ; [#uses = 1]
  %72 = sub nsw i64 %63, %69                      ; [#uses = 2]
  %73 = mul i64 %72, %72                          ; [#uses = 1]
  %74 = sub nsw i64 %66, %69                      ; [#uses = 2]
  %75 = mul i64 %74, %74                          ; [#uses = 1]
  %76 = add i64 %75, %71                          ; [#uses = 1]
  %77 = add i64 %76, %73                          ; [#uses = 2]
  %78 = load i64, i64* %3, align 8                ; [#uses = 1]
  %79 = icmp sgt i64 %78, %77                     ; [#uses = 1]
  br i1 %79, label %if.i.i80, label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81

if.i.i80:                                         ; preds = %if.i79
  store i64 %77, i64* %3, align 8
  br label %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81

_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81: ; preds = %andand.i73, %if.i79, %if.i.i80
  br i1 %.not110, label %forinc, label %if29

if29:                                             ; preds = %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81
  %80 = add i64 %k.1116, -1                       ; [#uses = 2]
  %81 = icmp ugt i64 %z_arg.fca.0.extract, %80    ; [#uses = 1]
  br i1 %81, label %if.i66, label %forinc

if.i66:                                           ; preds = %if29
  %82 = sext i32 %5 to i64                        ; [#uses = 2]
  %83 = getelementptr inbounds i32, i32* %y_arg.fca.1.extract, i64 %61 ; [#uses = 1, type = i32*]
  %84 = load i32, i32* %83, align 4               ; [#uses = 1]
  %85 = sext i32 %84 to i64                       ; [#uses = 2]
  %86 = getelementptr inbounds i32, i32* %z_arg.fca.1.extract, i64 %80 ; [#uses = 1, type = i32*]
  %87 = load i32, i32* %86, align 4               ; [#uses = 1]
  %88 = sext i32 %87 to i64                       ; [#uses = 2]
  %89 = sub nsw i64 %82, %85                      ; [#uses = 2]
  %90 = mul i64 %89, %89                          ; [#uses = 1]
  %91 = sub nsw i64 %82, %88                      ; [#uses = 2]
  %92 = mul i64 %91, %91                          ; [#uses = 1]
  %93 = sub nsw i64 %85, %88                      ; [#uses = 2]
  %94 = mul i64 %93, %93                          ; [#uses = 1]
  %95 = add i64 %94, %90                          ; [#uses = 1]
  %96 = add i64 %95, %92                          ; [#uses = 2]
  %97 = load i64, i64* %3, align 8                ; [#uses = 1]
  %98 = icmp sgt i64 %97, %96                     ; [#uses = 1]
  br i1 %98, label %if.i.i67, label %forinc

if.i.i67:                                         ; preds = %if.i66
  store i64 %96, i64* %3, align 8
  br label %forinc

forinc:                                           ; preds = %if27, %if.i.i67, %if.i66, %if29, %endif, %_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv.exit81
  %99 = add nuw i64 %__key185.0127, 1             ; [#uses = 2]
  %exitcond137.not = icmp eq i64 %99, %.len       ; [#uses = 1]
  br i1 %exitcond137.not, label %endfor, label %bounds.ok

endfor:                                           ; preds = %forinc, %0
  ret void
}

; [#uses = 0]
; Function Attrs: nofree norecurse nounwind uwtable
define void @_D6source4mainFZ1fMFIAiIQdIQgZ2goMFNaNbNiNfmmZv(i8* nocapture nonnull readonly %.nest_arg, i64 %v_arg, i64 %u_arg) local_unnamed_addr #6 {
  %y = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %1 = bitcast i8* %y to i64*                     ; [#uses = 1]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %2 = icmp ugt i64 %.len, %u_arg                 ; [#uses = 1]
  br i1 %2, label %andand, label %endif

andand:                                           ; preds = %0
  %z = getelementptr inbounds i8, i8* %.nest_arg, i64 24 ; [#uses = 1, type = i8*]
  %3 = bitcast i8* %z to i64*                     ; [#uses = 1]
  %.len1 = load i64, i64* %3, align 8             ; [#uses = 1]
  %4 = icmp ugt i64 %.len1, %v_arg                ; [#uses = 1]
  br i1 %4, label %if, label %endif

if:                                               ; preds = %andand
  %5 = bitcast i8* %.nest_arg to i8**             ; [#uses = 1]
  %.frame.main14 = load i8*, i8** %5, align 8     ; [#uses = 1]
  %xv = getelementptr inbounds i8, i8* %.nest_arg, i64 40 ; [#uses = 1, type = i8*]
  %6 = bitcast i8* %xv to i32*                    ; [#uses = 1]
  %7 = load i32, i32* %6, align 4                 ; [#uses = 1]
  %8 = sext i32 %7 to i64                         ; [#uses = 2]
  %9 = getelementptr inbounds i8, i8* %.nest_arg, i64 16 ; [#uses = 1, type = i8*]
  %10 = bitcast i8* %9 to i32**                   ; [#uses = 1]
  %.ptr = load i32*, i32** %10, align 8           ; [#uses = 1]
  %11 = getelementptr inbounds i32, i32* %.ptr, i64 %u_arg ; [#uses = 1, type = i32*]
  %12 = load i32, i32* %11, align 4               ; [#uses = 1]
  %13 = sext i32 %12 to i64                       ; [#uses = 2]
  %14 = getelementptr inbounds i8, i8* %.nest_arg, i64 32 ; [#uses = 1, type = i8*]
  %15 = bitcast i8* %14 to i32**                  ; [#uses = 1]
  %.ptr9 = load i32*, i32** %15, align 8          ; [#uses = 1]
  %16 = getelementptr inbounds i32, i32* %.ptr9, i64 %v_arg ; [#uses = 1, type = i32*]
  %17 = load i32, i32* %16, align 4               ; [#uses = 1]
  %18 = sext i32 %17 to i64                       ; [#uses = 2]
  %19 = sub nsw i64 %8, %13                       ; [#uses = 2]
  %20 = mul i64 %19, %19                          ; [#uses = 1]
  %21 = sub nsw i64 %8, %18                       ; [#uses = 2]
  %22 = mul i64 %21, %21                          ; [#uses = 1]
  %23 = sub nsw i64 %13, %18                      ; [#uses = 2]
  %24 = mul i64 %23, %23                          ; [#uses = 1]
  %25 = add i64 %24, %20                          ; [#uses = 1]
  %26 = add i64 %25, %22                          ; [#uses = 2]
  %res.i = getelementptr inbounds i8, i8* %.frame.main14, i64 8 ; [#uses = 1, type = i8*]
  %27 = bitcast i8* %res.i to i64*                ; [#uses = 2]
  %28 = load i64, i64* %27, align 8               ; [#uses = 1]
  %29 = icmp sgt i64 %28, %26                     ; [#uses = 1]
  br i1 %29, label %if.i, label %endif

if.i:                                             ; preds = %if
  store i64 %26, i64* %27, align 8
  br label %endif

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

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

toElem.success:                                   ; preds = %0
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor204) #1
  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 %__tmpfordtor204) #1
  call void @_Unwind_Resume(i8* %2)
  unreachable
}

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

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

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

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

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

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

endif:                                            ; preds = %0
  ret i1 true
}

; [#uses = 1]
declare zeroext i1 @_D3std5stdio4File6isOpenMxFNaNbNdNfZb(%std.stdio.File* nonnull) local_unnamed_addr #1

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

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

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

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

endif:                                            ; preds = %0
  ret i1 true
}

; [#uses = 1]
declare zeroext i1 @_D3std5stdio4File5errorMxFNaNbNdNeZb(%std.stdio.File* nonnull) local_unnamed_addr #1

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

; [#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 #7 {
  %.makelvaluetmp = alloca { i64, i8* }, align 8  ; [#uses = 2, size/byte = 16]
  %.makelvaluetmp2 = alloca { i64, i8* }, align 8 ; [#uses = 2, size/byte = 16]
  %msg_arg.fca.1.extract = extractvalue { i64, i8* } %msg_arg, 1 ; [#uses = 2]
  %.newclass_gc_alloc = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D9Exception7__ClassZ) #4 ; [#uses = 5]
  %vtbl = bitcast %object.Object* %.newclass_gc_alloc to [10 x i8*]** ; [#uses = 1]
  store [10 x i8*]* @_D9Exception6__vtblZ, [10 x i8*]** %vtbl, align 8
  %1 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %1, align 8
  %2 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc, i64 1 ; [#uses = 1, type = %object.Object*]
  %3 = bitcast %object.Object* %2 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(60) %3, i8* nonnull align 8 dereferenceable(60) bitcast ({ i64, i8* }* getelementptr inbounds (%object.Exception, %object.Exception* @_D9Exception6__initZ, i64 0, i32 2) to i8*), i64 60, i1 false)
  %.not = icmp eq i8* %msg_arg.fca.1.extract, null ; [#uses = 1]
  br i1 %.not, label %condfalse, label %condtrue

condtrue:                                         ; preds = %0
  %a_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %msg_arg, 0 ; [#uses = 2]
  %4 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract.i.i) #1 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %4, 1     ; [#uses = 2]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i.i, i8* nonnull align 1 %msg_arg.fca.1.extract, i64 %a_arg.fca.0.extract.i.i, i1 false) #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.5, i64 0, i64 0), %condfalse ], [ %.ptr.i.i, %condtrue ] ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.makelvaluetmp2.sink, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.sink, i8** %7, align 8
  %.newclass_gc = bitcast %object.Object* %.newclass_gc_alloc to %object.Exception* ; [#uses = 1]
  %8 = tail call %object.Exception* @_D6object9Exception6__ctorMFNaNbNiNfAyaQdmCQBp9ThrowableZCQBx(%object.Exception* nonnull returned %.newclass_gc, %object.Throwable* null, i64 %line_arg, { i64, i8* } %file_arg, { i64, i8* }* nonnull byval align 8 %.makelvaluetmp2.sink) #1 ; [#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 = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4idupTxaZQjFNaNbNdNfAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %a_arg.fca.0.extract.i = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 2]
  %a_arg.fca.1.extract.i = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract.i) #1 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %1, 1       ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i, i8* align 1 %a_arg.fca.1.extract.i, i64 %a_arg.fca.0.extract.i, i1 false) #1
  ret { i64, i8* } %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D6object__T4_dupTxaTyaZQmFNaNbNeMAxaZAya({ i64, i8* } %a_arg) local_unnamed_addr #0 {
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %a_arg, 0 ; [#uses = 2]
  %a_arg.fca.1.extract = extractvalue { i64, i8* } %a_arg, 1 ; [#uses = 1]
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract) #1 ; [#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) #1
  ret { i64, i8* } %1
}

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

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

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

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

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

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

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

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

condtrue:                                         ; preds = %0
  %a_arg.fca.0.extract.i.i = extractvalue { i64, i8* } %msg_arg, 0 ; [#uses = 2]
  %4 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axa6__initZ to %object.TypeInfo*), i64 %a_arg.fca.0.extract.i.i) #1 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %4, 1     ; [#uses = 2]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %.ptr.i.i, i8* nonnull align 1 %msg_arg.fca.1.extract, i64 %a_arg.fca.0.extract.i.i, i1 false) #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* [ %.ptr.i.i, %condtrue ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, 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) #1 ; [#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 #1

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T14arrayAllocImplVbi0TAhTmZQBaFNaNbmZQp(i64 %_param_0_arg) local_unnamed_addr #0 {
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 %_param_0_arg) #8 ; [#uses = 1]
  ret { i64, i8* } %1
}

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i8 @_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh(%source.InputReader* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 2, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 2]
  %.not.i = icmp eq i64 %.unpack, 0               ; [#uses = 1]
  br i1 %.not.i, label %assertFailed.i, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit

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

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit: ; preds = %0
  %.elt3 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 2, type = i8**]
  %.unpack4 = load i8*, i8** %.elt3, align 8      ; [#uses = 2]
  %1 = load i8, i8* %.unpack4, align 1            ; [#uses = 1]
  %lowerbound.i = getelementptr inbounds i8, i8* %.unpack4, i64 1 ; [#uses = 1, type = i8*]
  %2 = add i64 %.unpack, -1                       ; [#uses = 1]
  store i64 %2, i64* %.elt, align 8
  store i8* %lowerbound.i, i8** %.elt3, align 8
  ret i8 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i8 @_D6source11InputReader__T8nextByteVbi1ZQoMFZh(%source.InputReader* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 3, 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 %if, label %._D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit_crit_edge

._D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit_crit_edge: ; preds = %0
  %.unpack922.in.phi.trans.insert = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 1, type = i8**]
  %.unpack922.pre = load i8*, i8** %.unpack922.in.phi.trans.insert, align 8 ; [#uses = 1]
  br label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit

if:                                               ; preds = %0
  %2 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 4 ; [#uses = 2, type = i8*]
  %3 = load i8, i8* %2, align 1, !range !15       ; [#uses = 1]
  %.not.i12 = icmp eq i8 %3, 0                    ; [#uses = 1]
  br i1 %.not.i12, label %endif.i, label %if1

endif.i:                                          ; preds = %if
  %4 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.elt.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 1, type = i64*]
  %.unpack.i = load i64, i64* %.elt.i, align 8    ; [#uses = 1]
  %5 = insertvalue { i64, i8* } undef, i64 %.unpack.i, 0 ; [#uses = 1]
  %.elt9.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 1, type = i8**]
  %.unpack10.i = load i8*, i8** %.elt9.i, align 8 ; [#uses = 1]
  %6 = insertvalue { i64, i8* } %5, i8* %.unpack10.i, 1 ; [#uses = 1]
  %7 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %4, { i64, i8* } %6) #1 ; [#uses = 2]
  %.ptr.i13 = extractvalue { i64, i8* } %7, 1     ; [#uses = 2]
  %.len.i14 = extractvalue { i64, i8* } %7, 0     ; [#uses = 3]
  store i64 %.len.i14, i64* %1, align 8
  %8 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 1, type = i8**]
  store i8* %.ptr.i13, i8** %8, align 8
  %.not.i.i = icmp eq i64 %.len.i14, 0            ; [#uses = 1]
  br i1 %.not.i.i, label %if1.i, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit

if1.i:                                            ; preds = %endif.i
  store i8 1, i8* %2, align 1
  br label %if1

if1:                                              ; preds = %if1.i, %if
  ret i8 0

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit: ; preds = %endif.i, %._D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit_crit_edge
  %.unpack922 = phi i8* [ %.unpack922.pre, %._D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit_crit_edge ], [ %.ptr.i13, %endif.i ] ; [#uses = 2, type = i8*]
  %.unpack21 = phi i64 [ %.len.i, %._D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit_crit_edge ], [ %.len.i14, %endif.i ] ; [#uses = 1, type = i64]
  %.unpack922.in = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 1, type = i8**]
  %9 = load i8, i8* %.unpack922, align 1          ; [#uses = 1]
  %lowerbound.i = getelementptr inbounds i8, i8* %.unpack922, i64 1 ; [#uses = 1, type = i8*]
  %10 = add i64 %.unpack21, -1                    ; [#uses = 1]
  store i64 %10, i64* %1, align 8
  store i8* %lowerbound.i, i8** %.unpack922.in, align 8
  ret i8 %9
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std5array__T18uninitializedArrayTAiTxiZQBbFNaNbNexiZQt(i32 %_param_0_arg) local_unnamed_addr #0 {
  %1 = sext i32 %_param_0_arg to i64              ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %1) #8 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %2, 1       ; [#uses = 1]
  %.len.i = extractvalue { i64, i8* } %2, 0       ; [#uses = 1]
  %3 = bitcast i8* %.ptr.i to i32*                ; [#uses = 1]
  %.fca.0.insert.i = insertvalue { i64, i32* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %.fca.1.insert8.i = insertvalue { i64, i32* } %.fca.0.insert.i, i32* %3, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8.i
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i32 @_D6source11InputReader__T4nextTiZQiMFZi(%source.InputReader* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 0 ; [#uses = 9, type = i64*]
  %.elt8.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 2, i32 1 ; [#uses = 9, type = i8**]
  %1 = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 4 ; [#uses = 6, type = i8*]
  %.elt.i.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 0 ; [#uses = 3, type = i64*]
  %.elt9.i.i = getelementptr inbounds %source.InputReader, %source.InputReader* %.this_arg, i64 0, i32 3, i32 1 ; [#uses = 3, type = i8**]
  %.unpack.pre.i = load i64, i64* %.elt.i, align 8 ; [#uses = 1]
  %.unpack9.pre.i = load i8*, i8** %.elt8.i, align 8 ; [#uses = 1]
  br label %forcond.i

forcond.i:                                        ; preds = %endif.i.i, %0
  %.unpack9.i = phi i8* [ %.ptr.i.i, %endif.i.i ], [ %.unpack9.pre.i, %0 ] ; [#uses = 3, type = i8*]
  %.unpack.i = phi i64 [ %.len.i.i, %endif.i.i ], [ %.unpack.pre.i, %0 ] ; [#uses = 3, type = i64]
  %.not.i20.i.i = icmp eq i64 %.unpack.i, 0       ; [#uses = 1]
  br i1 %.not.i20.i.i, label %endif.i, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i: ; preds = %forcond.i
  %scevgep.i.i = getelementptr i8, i8* %.unpack9.i, i64 %.unpack.i ; [#uses = 1, type = i8*]
  br label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i

_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i: ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i
  %haystack.sroa.0.022.i.i = phi i64 [ %.unpack.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i ], [ %3, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 3, type = i64]
  %.unpack4.i = phi i8* [ %.unpack9.i, %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.lr.ph.i.i ], [ %lowerbound.i.i.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 5, type = i8*]
  %2 = load i8, i8* %.unpack4.i, align 1          ; [#uses = 1]
  %.not.i.i = icmp ult i8 %2, 45                  ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, label %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit

_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i
  %lowerbound.i.i.i = getelementptr inbounds i8, i8* %.unpack4.i, i64 1 ; [#uses = 1, type = i8*]
  %3 = add i64 %haystack.sroa.0.022.i.i, -1       ; [#uses = 2]
  %.not.i.i.i = icmp eq i64 %3, 0                 ; [#uses = 1]
  br i1 %.not.i.i.i, label %endif.i, label %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i

endif.i:                                          ; preds = %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i, %forcond.i
  %haystack.sroa.6.0.lcssa.i.ph.i = phi i8* [ %.unpack9.i, %forcond.i ], [ %scevgep.i.i, %_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv.exit.i.i ] ; [#uses = 1, type = i8*]
  store i64 0, i64* %.elt.i, align 8
  store i8* %haystack.sroa.6.0.lcssa.i.ph.i, i8** %.elt8.i, align 8
  %4 = load i8, i8* %1, align 1, !range !15       ; [#uses = 1]
  %.not.i10.i = icmp eq i8 %4, 0                  ; [#uses = 1]
  br i1 %.not.i10.i, label %endif.i.i, label %if

endif.i.i:                                        ; preds = %endif.i
  %5 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i.i = load i64, i64* %.elt.i.i, align 8 ; [#uses = 1]
  %6 = insertvalue { i64, i8* } undef, i64 %.unpack.i.i, 0 ; [#uses = 1]
  %.unpack10.i.i = load i8*, i8** %.elt9.i.i, align 8 ; [#uses = 1]
  %7 = insertvalue { i64, i8* } %6, i8* %.unpack10.i.i, 1 ; [#uses = 1]
  %8 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %5, { i64, i8* } %7) #1 ; [#uses = 2]
  %.ptr.i.i = extractvalue { i64, i8* } %8, 1     ; [#uses = 2]
  %.len.i.i = extractvalue { i64, i8* } %8, 0     ; [#uses = 3]
  store i64 %.len.i.i, i64* %.elt.i, align 8
  store i8* %.ptr.i.i, i8** %.elt8.i, align 8
  %.not.i.i11.i = icmp eq i64 %.len.i.i, 0        ; [#uses = 1]
  br i1 %.not.i.i11.i, label %if1.i.i, label %forcond.i

if1.i.i:                                          ; preds = %endif.i.i
  store i8 1, i8* %1, align 1
  br label %if

if:                                               ; preds = %endif.i, %if.i49, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65, %if.i, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit, %if1.i.i58, %if1.i.i41, %if1.i.i
  %merge = phi i32 [ 0, %if1.i.i ], [ %res.0, %if1.i.i41 ], [ %res.1, %if1.i.i58 ], [ %res.0, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit ], [ %res.0, %if.i ], [ %res.1, %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65 ], [ %res.1, %if.i49 ], [ 0, %endif.i ] ; [#uses = 1, type = i32]
  ret i32 %merge

_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit: ; preds = %_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh.exit.i.i
  store i64 %haystack.sroa.0.022.i.i, i64* %.elt.i, align 8
  store i8* %.unpack4.i, i8** %.elt8.i, align 8
  %9 = load i8, i8* %.unpack4.i, align 1          ; [#uses = 2]
  %lowerbound.i.i = getelementptr inbounds i8, i8* %.unpack4.i, i64 1 ; [#uses = 3, type = i8*]
  %10 = add i64 %haystack.sroa.0.022.i.i, -1      ; [#uses = 3]
  store i64 %10, i64* %.elt.i, align 8
  store i8* %lowerbound.i.i, i8** %.elt8.i, align 8
  %11 = icmp eq i8 %9, 45                         ; [#uses = 1]
  br i1 %11, label %forcond, label %else

forcond:                                          ; preds = %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit, %endif4
  %.unpack922.pre.i = phi i8* [ %lowerbound.i.i42, %endif4 ], [ %lowerbound.i.i, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 1, type = i8*]
  %.len.i.i33 = phi i64 [ %18, %endif4 ], [ %10, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 2, type = i64]
  %res.0 = phi i32 [ %22, %endif4 ], [ 0, %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit ] ; [#uses = 4, type = i32]
  %.not.i.i34 = icmp eq i64 %.len.i.i33, 0        ; [#uses = 1]
  br i1 %.not.i.i34, label %if.i, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit

if.i:                                             ; preds = %forcond
  %12 = load i8, i8* %1, align 1, !range !15      ; [#uses = 1]
  %.not.i12.i = icmp eq i8 %12, 0                 ; [#uses = 1]
  br i1 %.not.i12.i, label %endif.i.i40, label %if

endif.i.i40:                                      ; preds = %if.i
  %13 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i.i36 = load i64, i64* %.elt.i.i, align 8 ; [#uses = 1]
  %14 = insertvalue { i64, i8* } undef, i64 %.unpack.i.i36, 0 ; [#uses = 1]
  %.unpack10.i.i38 = load i8*, i8** %.elt9.i.i, align 8 ; [#uses = 1]
  %15 = insertvalue { i64, i8* } %14, i8* %.unpack10.i.i38, 1 ; [#uses = 1]
  %16 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %13, { i64, i8* } %15) #1 ; [#uses = 2]
  %.ptr.i13.i = extractvalue { i64, i8* } %16, 1  ; [#uses = 2]
  %.len.i14.i = extractvalue { i64, i8* } %16, 0  ; [#uses = 3]
  store i64 %.len.i14.i, i64* %.elt.i, align 8
  store i8* %.ptr.i13.i, i8** %.elt8.i, align 8
  %.not.i.i.i39 = icmp eq i64 %.len.i14.i, 0      ; [#uses = 1]
  br i1 %.not.i.i.i39, label %if1.i.i41, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit

if1.i.i41:                                        ; preds = %endif.i.i40
  store i8 1, i8* %1, align 1
  br label %if

_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit: ; preds = %forcond, %endif.i.i40
  %.unpack922.i = phi i8* [ %.ptr.i13.i, %endif.i.i40 ], [ %.unpack922.pre.i, %forcond ] ; [#uses = 2, type = i8*]
  %.unpack21.i = phi i64 [ %.len.i14.i, %endif.i.i40 ], [ %.len.i.i33, %forcond ] ; [#uses = 1, type = i64]
  %17 = load i8, i8* %.unpack922.i, align 1       ; [#uses = 2]
  %lowerbound.i.i42 = getelementptr inbounds i8, i8* %.unpack922.i, i64 1 ; [#uses = 2, type = i8*]
  %18 = add i64 %.unpack21.i, -1                  ; [#uses = 2]
  store i64 %18, i64* %.elt.i, align 8
  store i8* %lowerbound.i.i42, i8** %.elt8.i, align 8
  %.off29 = add i8 %17, -48                       ; [#uses = 1]
  %19 = icmp ugt i8 %.off29, 9                    ; [#uses = 1]
  br i1 %19, label %if, label %endif4

endif4:                                           ; preds = %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit
  %20 = zext i8 %17 to i32                        ; [#uses = 1]
  %21 = mul i32 %res.0, 10                        ; [#uses = 1]
  %.neg69 = add i32 %21, 48                       ; [#uses = 1]
  %22 = sub i32 %.neg69, %20                      ; [#uses = 1]
  br label %forcond

else:                                             ; preds = %_D6source11InputReader__T8nextByteVbi0ZQoMFNaNbNiNfZh.exit
  %23 = zext i8 %9 to i32                         ; [#uses = 1]
  %24 = add nsw i32 %23, -48                      ; [#uses = 1]
  br label %forcond6

forcond6:                                         ; preds = %endif14, %else
  %.unpack922.pre.i46 = phi i8* [ %lowerbound.i.i, %else ], [ %lowerbound.i.i63, %endif14 ] ; [#uses = 1, type = i8*]
  %.len.i.i43 = phi i64 [ %10, %else ], [ %31, %endif14 ] ; [#uses = 2, type = i64]
  %res.1 = phi i32 [ %24, %else ], [ %36, %endif14 ] ; [#uses = 4, type = i32]
  %.not.i.i44 = icmp eq i64 %.len.i.i43, 0        ; [#uses = 1]
  br i1 %.not.i.i44, label %if.i49, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65

if.i49:                                           ; preds = %forcond6
  %25 = load i8, i8* %1, align 1, !range !15      ; [#uses = 1]
  %.not.i12.i48 = icmp eq i8 %25, 0               ; [#uses = 1]
  br i1 %.not.i12.i48, label %endif.i.i57, label %if

endif.i.i57:                                      ; preds = %if.i49
  %26 = tail call %std.stdio.File* @_D3std5stdio__T10makeGlobalVEQBbQBa13StdFileHandlea21_636f72652e737464632e737464696f2e737464696eZQDeFNbNcNdNiZSQEfQEe4File() #1 ; [#uses = 1]
  %.unpack.i.i51 = load i64, i64* %.elt.i.i, align 8 ; [#uses = 1]
  %27 = insertvalue { i64, i8* } undef, i64 %.unpack.i.i51, 0 ; [#uses = 1]
  %.unpack10.i.i53 = load i8*, i8** %.elt9.i.i, align 8 ; [#uses = 1]
  %28 = insertvalue { i64, i8* } %27, i8* %.unpack10.i.i53, 1 ; [#uses = 1]
  %29 = tail call { i64, i8* } @_D3std5stdio4File__T7rawReadThZQlMFNfAhZQd(%std.stdio.File* nonnull %26, { i64, i8* } %28) #1 ; [#uses = 2]
  %.ptr.i13.i54 = extractvalue { i64, i8* } %29, 1 ; [#uses = 2]
  %.len.i14.i55 = extractvalue { i64, i8* } %29, 0 ; [#uses = 3]
  store i64 %.len.i14.i55, i64* %.elt.i, align 8
  store i8* %.ptr.i13.i54, i8** %.elt8.i, align 8
  %.not.i.i.i56 = icmp eq i64 %.len.i14.i55, 0    ; [#uses = 1]
  br i1 %.not.i.i.i56, label %if1.i.i58, label %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65

if1.i.i58:                                        ; preds = %endif.i.i57
  store i8 1, i8* %1, align 1
  br label %if

_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65: ; preds = %forcond6, %endif.i.i57
  %.unpack922.i60 = phi i8* [ %.ptr.i13.i54, %endif.i.i57 ], [ %.unpack922.pre.i46, %forcond6 ] ; [#uses = 2, type = i8*]
  %.unpack21.i61 = phi i64 [ %.len.i14.i55, %endif.i.i57 ], [ %.len.i.i43, %forcond6 ] ; [#uses = 1, type = i64]
  %30 = load i8, i8* %.unpack922.i60, align 1     ; [#uses = 2]
  %lowerbound.i.i63 = getelementptr inbounds i8, i8* %.unpack922.i60, i64 1 ; [#uses = 2, type = i8*]
  %31 = add i64 %.unpack21.i61, -1                ; [#uses = 2]
  store i64 %31, i64* %.elt.i, align 8
  store i8* %lowerbound.i.i63, i8** %.elt8.i, align 8
  %.off = add i8 %30, -48                         ; [#uses = 1]
  %32 = icmp ugt i8 %.off, 9                      ; [#uses = 1]
  br i1 %32, label %if, label %endif14

endif14:                                          ; preds = %_D6source11InputReader__T8nextByteVbi1ZQoMFZh.exit65
  %33 = zext i8 %30 to i32                        ; [#uses = 1]
  %34 = mul i32 %res.1, 10                        ; [#uses = 1]
  %35 = add i32 %34, -48                          ; [#uses = 1]
  %36 = add i32 %35, %33                          ; [#uses = 1]
  br label %forcond6
}

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std5array__T14arrayAllocImplVbi0TAiTmZQBaFNaNbmZQp(i64 %_param_0_arg) local_unnamed_addr #0 {
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %_param_0_arg) #8 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %1, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %1, 0         ; [#uses = 1]
  %2 = bitcast i8* %.ptr to i32*                  ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i32* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert8 = insertvalue { i64, i32* } %.fca.0.insert, i32* %2, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAiZQkFNaNbNdNiNfMKQsZb({ i64, i32* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %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 void @_D3std5range10primitives__T8popFrontTiZQmFNaNbNiNfMKANgiZv({ i64, i32* }* dereferenceable(16) %a) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %a, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %.not = icmp eq i64 %.len, 0                    ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %bounds.ok

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T4swapTiZQiFNaNbNiNeKiKiZv(i32* dereferenceable(4) %rhs, i32* dereferenceable(4) %lhs) local_unnamed_addr #0 {
  %1 = load i32, i32* %lhs, align 4               ; [#uses = 1]
  %2 = load i32, i32* %rhs, align 4               ; [#uses = 1]
  store i32 %2, i32* %lhs, align 4
  store i32 %1, i32* %rhs, align 4
  ret void
}

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

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

bounds.ok:                                        ; preds = %0
  %2 = add i64 %.len, -1                          ; [#uses = 1]
  store i64 %2, i64* %1, align 8
  ret void

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

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

bounds.ok:                                        ; preds = %0
  %1 = add i64 %a_arg.fca.0.extract, -1           ; [#uses = 1]
  %a_arg.fca.1.extract = extractvalue { i64, i32* } %a_arg, 1 ; [#uses = 1]
  %2 = getelementptr inbounds i32, i32* %a_arg.fca.1.extract, i64 %1 ; [#uses = 1, type = i32*]
  ret i32* %2

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

; [#uses = 3]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDhFNaNbNiNfQpmZv(i64 %depth_arg, { i64, i32* } %r_arg) local_unnamed_addr #0 {
  %.lval_copy_for_ImplicitByvalRewrite.i = alloca { i64, i32* }, align 8 ; [#uses = 4, size/byte = 16]
  %left = alloca { i64, i32* }, align 8           ; [#uses = 3, size/byte = 16]
  %right = alloca { i64, i32* }, align 8          ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 3]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 2]
  %1 = icmp ugt i64 %r_arg.fca.0.extract, 256     ; [#uses = 1]
  br i1 %1, label %forbody.lr.ph, label %endfor

forbody.lr.ph:                                    ; preds = %0
  %2 = bitcast { i64, i32* }* %.lval_copy_for_ImplicitByvalRewrite.i to i8* ; [#uses = 3]
  %r.sroa.0.0..sroa_idx.i = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %r.sroa.8.0..sroa_idx17.i = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %left, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %4 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %left, i64 0, i32 1 ; [#uses = 2, type = i32**]
  %5 = bitcast i32** %4 to i64*                   ; [#uses = 1]
  %6 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %right, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %right, i64 0, i32 1 ; [#uses = 2, type = i32**]
  br label %forbody

forbody:                                          ; preds = %forbody.lr.ph, %endif52
  %.in = phi i32* [ %r_arg.fca.1.extract, %forbody.lr.ph ], [ %.ptr53, %endif52 ] ; [#uses = 11, type = i32*]
  %depth.0197 = phi i64 [ %depth_arg, %forbody.lr.ph ], [ %condtmp.0.sroa.speculated, %endif52 ] ; [#uses = 4, type = i64]
  %r.sroa.0.0194 = phi i64 [ %r_arg.fca.0.extract, %forbody.lr.ph ], [ %.len54, %endif52 ] ; [#uses = 23, type = i64]
  %8 = ptrtoint i32* %.in to i64                  ; [#uses = 1]
  %9 = icmp eq i64 %depth.0197, 0                 ; [#uses = 1]
  br i1 %9, label %if, label %endif

if:                                               ; preds = %forbody
  %.fca.0.insert79 = insertvalue { i64, i32* } undef, i64 %r.sroa.0.0194, 0 ; [#uses = 1]
  %.fca.1.insert82 = insertvalue { i64, i32* } %.fca.0.insert79, i32* %.in, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i32* } %.fca.1.insert82) #1
  ret void

endif:                                            ; preds = %forbody
  %10 = icmp ugt i64 %depth.0197, 9223372036854775806 ; [#uses = 1]
  br i1 %10, label %condtrue, label %condfalse

condtrue:                                         ; preds = %endif
  %11 = udiv i64 %depth.0197, 3                   ; [#uses = 1]
  %12 = shl nuw i64 %11, 1                        ; [#uses = 1]
  br label %condend

condfalse:                                        ; preds = %endif
  %13 = shl nuw i64 %depth.0197, 1                ; [#uses = 1]
  %14 = udiv i64 %13, 3                           ; [#uses = 1]
  br label %condend

condend:                                          ; preds = %condfalse, %condtrue
  %condtmp.0.sroa.speculated = phi i64 [ %12, %condtrue ], [ %14, %condfalse ] ; [#uses = 2, type = i64]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %2)
  %15 = lshr i64 %r.sroa.0.0194, 1                ; [#uses = 7]
  %16 = icmp ult i64 %r.sroa.0.0194, 512          ; [#uses = 1]
  br i1 %16, label %endif4.i, label %endif.i

endif4.i:                                         ; preds = %condend
  %.fca.0.insert85 = insertvalue { i64, i32* } undef, i64 %r.sroa.0.0194, 0 ; [#uses = 1]
  %.fca.1.insert88 = insertvalue { i64, i32* } %.fca.0.insert85, i32* %.in, 1 ; [#uses = 1]
  %17 = add nsw i64 %r.sroa.0.0194, -1            ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmZQFiFNaNbNiNfQvmmmZv(i64 %17, i64 %15, i64 0, { i64, i32* } %.fca.1.insert88) #1
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2)
  br label %_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm.exit

endif.i:                                          ; preds = %condend
  %18 = lshr i64 %r.sroa.0.0194, 2                ; [#uses = 2]
  store i64 %r.sroa.0.0194, i64* %r.sroa.0.0..sroa_idx.i, align 8
  store i32* %.in, i32** %r.sroa.8.0..sroa_idx17.i, align 8
  %19 = sub nsw i64 %15, %18                      ; [#uses = 1]
  %20 = add nuw i64 %15, %18                      ; [#uses = 1]
  %21 = add i64 %r.sroa.0.0194, -1                ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmTmTmZQFmFNaNbNiNfQzmmmmmZv(i64 %21, i64 %20, i64 %15, i64 %19, i64 0, { i64, i32* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite.i) #1
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2)
  br label %_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm.exit

_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm.exit: ; preds = %endif.i, %endif4.i
  %bounds.cmp = icmp ult i64 %15, %r.sroa.0.0194  ; [#uses = 1]
  br i1 %bounds.cmp, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %bounds.fail

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm.exit
  %22 = getelementptr inbounds i32, i32* %.in, i64 %15 ; [#uses = 2, type = i32*]
  %23 = load i32, i32* %22, align 4               ; [#uses = 3]
  %24 = add i64 %r.sroa.0.0194, -1                ; [#uses = 2]
  %25 = getelementptr inbounds i32, i32* %.in, i64 %24 ; [#uses = 4, type = i32*]
  %26 = load i32, i32* %25, align 4               ; [#uses = 1]
  store i32 %26, i32* %22, align 4
  store i32 %23, i32* %25, align 4
  br label %forcond5

forcond5:                                         ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit108, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit
  %lessI.0 = phi i64 [ -1, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %27, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit108 ] ; [#uses = 2, type = i64]
  %greaterI.0 = phi i64 [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %35, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit108 ] ; [#uses = 2, type = i64]
  br label %forcond9

forcond9:                                         ; preds = %bounds.ok15, %forcond5
  %lessI.1 = phi i64 [ %lessI.0, %forcond5 ], [ %27, %bounds.ok15 ] ; [#uses = 2, type = i64]
  %27 = add i64 %lessI.1, 1                       ; [#uses = 13]
  %bounds.cmp14 = icmp ult i64 %27, %r.sroa.0.0194 ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %forcond9
  %28 = getelementptr inbounds i32, i32* %.in, i64 %27 ; [#uses = 1, type = i32*]
  %29 = load i32, i32* %28, align 4               ; [#uses = 3]
  %30 = icmp slt i32 %29, %23                     ; [#uses = 1]
  br i1 %30, label %forcond9, label %endfor12

bounds.fail16:                                    ; preds = %forcond9
  %31 = add i64 %lessI.0, 1                       ; [#uses = 2]
  %32 = icmp ugt i64 %r.sroa.0.0194, %31          ; [#uses = 1]
  %umax = select i1 %32, i64 %r.sroa.0.0194, i64 %31 ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2175, i64 %umax, i64 %r.sroa.0.0194) #5
  unreachable

endfor12:                                         ; preds = %bounds.ok15
  %33 = getelementptr inbounds i32, i32* %.in, i64 %27 ; [#uses = 2, type = i32*]
  %.not = icmp ugt i64 %27, %greaterI.0           ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %forcond18

forcond18:                                        ; preds = %endfor12, %bounds.ok26
  %greaterI.1 = phi i64 [ %35, %bounds.ok26 ], [ %greaterI.0, %endfor12 ] ; [#uses = 2, type = i64]
  %34 = icmp eq i64 %greaterI.1, %27              ; [#uses = 1]
  br i1 %34, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit116, label %endif23

endif23:                                          ; preds = %forcond18
  %35 = add i64 %greaterI.1, -1                   ; [#uses = 8]
  %bounds.cmp25 = icmp ult i64 %35, %r.sroa.0.0194 ; [#uses = 1]
  br i1 %bounds.cmp25, label %bounds.ok26, label %bounds.fail27

bounds.ok26:                                      ; preds = %endif23
  %36 = getelementptr inbounds i32, i32* %.in, i64 %35 ; [#uses = 1, type = i32*]
  %37 = load i32, i32* %36, align 4               ; [#uses = 2]
  %38 = icmp slt i32 %23, %37                     ; [#uses = 1]
  br i1 %38, label %forcond18, label %endfor21

bounds.fail27:                                    ; preds = %endif23
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2180, i64 %35, i64 %r.sroa.0.0194) #5
  unreachable

endfor21:                                         ; preds = %bounds.ok26
  %39 = getelementptr inbounds i32, i32* %.in, i64 %35 ; [#uses = 1, type = i32*]
  %.not99 = icmp ugt i64 %27, %35                 ; [#uses = 1]
  br i1 %.not99, label %assertFailed33, label %assertPassed32

assertPassed32:                                   ; preds = %endfor21
  %40 = icmp eq i64 %27, %35                      ; [#uses = 1]
  br i1 %40, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit116, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit108

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit108: ; preds = %assertPassed32
  store i32 %37, i32* %33, align 4
  store i32 %29, i32* %39, align 4
  br label %forcond5

assertFailed33:                                   ; preds = %endfor21
  call void @_d_assert_msg({ i64, i8* } { i64 34, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.16, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2182) #5
  unreachable

assertFailed:                                     ; preds = %endfor12
  call void @_d_assert_msg({ i64, i8* } { i64 34, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.16, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2176) #5
  unreachable

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit116: ; preds = %assertPassed32, %forcond18
  %41 = load i32, i32* %25, align 4               ; [#uses = 1]
  store i32 %29, i32* %25, align 4
  store i32 %41, i32* %33, align 4
  %bounds.cmp.up.not = icmp ugt i64 %27, %r.sroa.0.0194 ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail39, label %bounds.ok38

bounds.ok38:                                      ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit116
  store i64 %27, i64* %3, align 8
  store i64 %8, i64* %5, align 8
  %42 = add i64 %lessI.1, 2                       ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %r.sroa.0.0194, %42 ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail44, label %bounds.ok43

bounds.ok43:                                      ; preds = %bounds.ok38
  %lowerbound48 = getelementptr inbounds i32, i32* %.in, i64 %42 ; [#uses = 2, type = i32*]
  %43 = sub i64 %r.sroa.0.0194, %42               ; [#uses = 3]
  store i64 %43, i64* %6, align 8
  store i32* %lowerbound48, i32** %7, align 8
  %44 = icmp ugt i64 %43, %27                     ; [#uses = 1]
  br i1 %44, label %if51, label %endif52

if51:                                             ; preds = %bounds.ok43
  call void @_D3std9algorithm8mutation__T4swapTAiZQjFNaNbNiNeKQpKQsZv({ i64, i32* }* nonnull dereferenceable(16) %right, { i64, i32* }* nonnull dereferenceable(16) %left) #1
  %.fca.0.load.pre = load i64, i64* %6, align 8   ; [#uses = 1]
  %.fca.1.load.pre = load i32*, i32** %7, align 8 ; [#uses = 1]
  br label %endif52

endif52:                                          ; preds = %if51, %bounds.ok43
  %.fca.1.load = phi i32* [ %.fca.1.load.pre, %if51 ], [ %lowerbound48, %bounds.ok43 ] ; [#uses = 1, type = i32*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %if51 ], [ %43, %bounds.ok43 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, i32* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i32* } %.fca.0.insert, i32* %.fca.1.load, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDhFNaNbNiNfQpmZv(i64 %condtmp.0.sroa.speculated, { i64, i32* } %.fca.1.insert) #0
  %.ptr53 = load i32*, i32** %4, align 8          ; [#uses = 2]
  %.len54 = load i64, i64* %3, align 8            ; [#uses = 3]
  %45 = icmp ugt i64 %.len54, 256                 ; [#uses = 1]
  br i1 %45, label %forbody, label %endfor

bounds.fail44:                                    ; preds = %bounds.ok38
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2188, i64 %42, i64 %r.sroa.0.0194, i64 %r.sroa.0.0194) #5
  unreachable

bounds.fail39:                                    ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit116
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2188, i64 0, i64 %27, i64 %r.sroa.0.0194) #5
  unreachable

bounds.fail:                                      ; preds = %_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm.exit
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2166, i64 %15, i64 %r.sroa.0.0194) #5
  unreachable

endfor:                                           ; preds = %endif52, %0
  %r.sroa.0.0.lcssa = phi i64 [ %r_arg.fca.0.extract, %0 ], [ %.len54, %endif52 ] ; [#uses = 1, type = i64]
  %storemerge.lcssa = phi i32* [ %r_arg.fca.1.extract, %0 ], [ %.ptr53, %endif52 ] ; [#uses = 1, type = i32*]
  %.fca.0.insert91 = insertvalue { i64, i32* } undef, i64 %r.sroa.0.0.lcssa, 0 ; [#uses = 1]
  %.fca.1.insert94 = insertvalue { i64, i32* } %.fca.0.insert91, i32* %storemerge.lcssa, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDcFNaNbNiNfQpZv({ i64, i32* } %.fca.1.insert94) #1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm7sorting__T8isSortedSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZb({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 2]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 2]
  %.not.i = icmp eq i64 %r_arg.fca.0.extract, 0   ; [#uses = 1]
  br i1 %.not.i, label %if, label %endif

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

endif:                                            ; preds = %0
  %1 = add i64 %r_arg.fca.0.extract, -1           ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %bounds.ok4, %endif
  %__key173.0 = phi i64 [ 0, %endif ], [ %2, %bounds.ok4 ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %__key173.0, %1     ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %bounds.ok4

bounds.ok4:                                       ; preds = %forcond
  %2 = add nuw i64 %__key173.0, 1                 ; [#uses = 2]
  %3 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %2 ; [#uses = 1, type = i32*]
  %4 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %__key173.0 ; [#uses = 1, type = i32*]
  %5 = load i32, i32* %3, align 4                 ; [#uses = 1]
  %6 = load i32, i32* %4, align 4                 ; [#uses = 1]
  %7 = icmp slt i32 %5, %6                        ; [#uses = 1]
  br i1 %7, label %if, label %forcond
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T12assumeSortedVAyaa5_61203c2062TAiZQBjFNaNbNiNfQpZSQCmQCl__T11SortedRangeTQBqVQCla5_61203c2062VEQEfQEe18SortedRangeOptionsi0ZQCn({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %input_arg.fca.0.extract.i = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %input_arg.fca.0.extract.i, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i32* %input_arg.fca.1.extract.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm6__ctorMFNaNbNcNiNfQCuZSQEaQDz__TQDwTQDmVQDna5_61203c2062VQDni0ZQFb(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull returned %.this_arg, { i64, i32* } %input_arg) local_unnamed_addr #0 {
  %input_arg.fca.0.extract = extractvalue { i64, i32* } %input_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract = extractvalue { i64, i32* } %input_arg, 1 ; [#uses = 1]
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %input_arg.fca.0.extract, i64* %1, align 8
  %2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  store i32* %input_arg.fca.1.extract, i32** %2, align 8
  ret %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm5emptyMFNaNbNdNiNfZb(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %1, align 8            ; [#uses = 1]
  %.not.i = icmp eq i64 %.len.i, 0                ; [#uses = 1]
  ret i1 %.not.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm4saveMFNaNbNdNiNfZSQDvQDu__TQDrTQDhVQDia5_61203c2062VQDii0ZQEw(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %.elt2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %.unpack3 = load i32*, i32** %.elt2, align 8    ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %.unpack, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i32* %.unpack3, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32* @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm5frontMFNaNbNcNdNiNfZi(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 1]
  %.not.i = icmp eq i64 %.unpack, 0               ; [#uses = 1]
  br i1 %.not.i, label %assertFailed.i, label %_D3std5range10primitives__T5frontTiZQjFNaNbNcNdNiNfMNkANgiZNgi.exit

assertFailed.i:                                   ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 54, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.9, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.7, i32 0, i32 0) }, i32 2472) #5
  unreachable

_D3std5range10primitives__T5frontTiZQjFNaNbNcNdNiNfMNkANgiZNgi.exit: ; preds = %0
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %.unpack2 = load i32*, i32** %.elt1, align 8    ; [#uses = 1]
  ret i32* %.unpack2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm8popFrontMFNaNbNiNfZv(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 2, 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.i, label %_D3std5range10primitives__T8popFrontTiZQmFNaNbNiNfMKANgiZv.exit

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

_D3std5range10primitives__T8popFrontTiZQmFNaNbNiNfMKANgiZv.exit: ; preds = %0
  %2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 2, type = i32**]
  %.ptr.i = load i32*, i32** %2, align 8          ; [#uses = 1]
  %lowerbound.i = getelementptr inbounds i32, i32* %.ptr.i, i64 1 ; [#uses = 1, type = i32*]
  %3 = add i64 %.len.i, -1                        ; [#uses = 1]
  store i64 %3, i64* %1, align 8
  store i32* %lowerbound.i, i32** %2, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32* @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm4backMFNaNbNcNdNiNfZi(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 2]
  %.not.i = icmp eq i64 %.unpack, 0               ; [#uses = 1]
  br i1 %.not.i, label %assertFailed.i, label %_D3std5range10primitives__T4backTiZQiFNaNbNcNdNiNfMNkANgiZNgi.exit

assertFailed.i:                                   ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 53, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.11, i32 0, i32 0) }, { i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.7, i32 0, i32 0) }, i32 2518) #5
  unreachable

_D3std5range10primitives__T4backTiZQiFNaNbNcNdNiNfMNkANgiZNgi.exit: ; preds = %0
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %.unpack2 = load i32*, i32** %.elt1, align 8    ; [#uses = 1]
  %1 = add i64 %.unpack, -1                       ; [#uses = 1]
  %2 = getelementptr inbounds i32, i32* %.unpack2, i64 %1 ; [#uses = 1, type = i32*]
  ret i32* %2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm7popBackMFNaNbNiNfZv(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 2, 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.i, label %_D3std5range10primitives__T7popBackTiZQlFNaNbNiNfMKANgiZv.exit

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

_D3std5range10primitives__T7popBackTiZQlFNaNbNiNfMKANgiZv.exit: ; preds = %0
  %2 = add i64 %.len.i, -1                        ; [#uses = 1]
  store i64 %2, i64* %1, align 8
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32* @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm7opIndexMFNaNbNcNiNfmZi(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %i_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %bounds.cmp = icmp ugt i64 %.len, %i_arg        ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %0
  %2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr = load i32*, i32** %2, align 8            ; [#uses = 1]
  %3 = getelementptr inbounds i32, i32* %.ptr, i64 %i_arg ; [#uses = 1, type = i32*]
  ret i32* %3

bounds.fail:                                      ; preds = %0
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 59, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.14, i32 0, i32 0) }, i32 10828, i64 %i_arg, i64 %.len) #5
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm7opSliceMFNaNbNiNjNfmmZSQEaQDz__TQDwTQDmVQDna5_61203c2062VQDni0ZQFb(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %b_arg, i64 %a_arg) local_unnamed_addr #0 {
  %.not = icmp ult i64 %b_arg, %a_arg             ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %0
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 2]
  %bounds.cmp.up.not = icmp ult i64 %.len, %b_arg ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %assertPassed
  %2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr = load i32*, i32** %2, align 8            ; [#uses = 1]
  %lowerbound = getelementptr inbounds i32, i32* %.ptr, i64 %a_arg ; [#uses = 1, type = i32*]
  %3 = sub i64 %b_arg, %a_arg                     ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %3, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i32* %lowerbound, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert

bounds.fail:                                      ; preds = %assertPassed
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 59, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.14, i32 0, i32 0) }, i32 10840, i64 %a_arg, i64 %b_arg, i64 %.len) #5
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 79, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } { i64 59, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.14, i32 0, i32 0) }, i32 10835) #5
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm9__mixin246lengthMFNaNbNdNiNfZm(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  ret i64 %.len
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm7releaseMFNaNbNiNjNfZQCw(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #0 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i.i.i.i = load i64, i64* %1, align 8    ; [#uses = 2]
  %2 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2.i.i.i.i.i = load i8*, i8** %3, align 8   ; [#uses = 7]
  %4 = shl i64 %.len.i.i.i.i.i, 2                 ; [#uses = 1]
  %5 = bitcast %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg to i8* ; [#uses = 4]
  %6 = getelementptr inbounds i8, i8* %.ptr2.i.i.i.i.i, i64 %4 ; [#uses = 3, type = i8*]
  %7 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 1, i32 0 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 3]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i.i.i.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i.i.i.i.i.i = icmp ule i8* %.ptr2.i.i.i.i.i, %5 ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i.i.i.i.i.i = and i1 %.not.i.i.i.i.i.i, %10 ; [#uses = 1]
  %11 = ptrtoint i8* %.ptr2.i.i.i.i.i to i64      ; [#uses = 1]
  br i1 %andandval.i.i.i.i.i.i, label %if.i.i.i.i.i.i, label %endif.i.i.i.i.i.i

if.i.i.i.i.i.i:                                   ; preds = %0
  %12 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i.i.i to i64 ; [#uses = 1]
  %13 = ptrtoint %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg to i64 ; [#uses = 1]
  %14 = sub i64 %12, %13                          ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i

endif.i.i.i.i.i.i:                                ; preds = %0
  %.not28.i.i.i.i.i.i = icmp uge i8* %.ptr2.i.i.i.i.i, %5 ; [#uses = 1]
  %17 = icmp ult i8* %.ptr2.i.i.i.i.i, %8         ; [#uses = 1]
  %andandval17.i.i.i.i.i.i = and i1 %.not28.i.i.i.i.i.i, %17 ; [#uses = 1]
  br i1 %andandval17.i.i.i.i.i.i, label %if18.i.i.i.i.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i

if18.i.i.i.i.i.i:                                 ; preds = %endif.i.i.i.i.i.i
  %18 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i.i.i to i64 ; [#uses = 1]
  %19 = sub i64 %18, %11                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2.i.i.i.i.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i: ; preds = %if18.i.i.i.i.i.i, %endif.i.i.i.i.i.i, %if.i.i.i.i.i.i
  %22 = phi { i64, i8* } [ %16, %if.i.i.i.i.i.i ], [ %21, %if18.i.i.i.i.i.i ], [ zeroinitializer, %endif.i.i.i.i.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i.i.i.i.i = extractvalue { i64, i8* } %22, 0 ; [#uses = 1]
  %.not.i.i.i.i = icmp eq i64 %.len1.i.i.i.i.i, 0 ; [#uses = 1]
  br i1 %.not.i.i.i.i, label %_D3std9algorithm8mutation__T4moveTAiZQjFNaNbNiNfMNkKQsZQv.exit, label %assertFailed.i.i.i.i

assertFailed.i.i.i.i:                             ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.38, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 1429) #5
  unreachable

_D3std9algorithm8mutation__T4moveTAiZQjFNaNbNiNfMNkKQsZQv.exit: ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i.i
  %.fca.0.insert.i.i.i = insertvalue { i64, i32* } undef, i64 %.len.i.i.i.i.i, 0 ; [#uses = 1]
  %23 = bitcast i8* %.ptr2.i.i.i.i.i to i32*      ; [#uses = 1]
  %.fca.1.insert6.i.i.i = insertvalue { i64, i32* } %.fca.0.insert.i.i.i, i32* %23, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert6.i.i.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std9algorithm8mutation__T4moveTAiZQjFNaNbNiNfMNkKQsZQv({ i64, i32* }* dereferenceable(16) %source) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i.i.i = load i64, i64* %1, align 8      ; [#uses = 2]
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2.i.i.i.i = load i8*, i8** %3, align 8     ; [#uses = 7]
  %4 = shl i64 %.len.i.i.i.i, 2                   ; [#uses = 1]
  %5 = bitcast { i64, i32* }* %source to i8*      ; [#uses = 4]
  %6 = getelementptr inbounds i8, i8* %.ptr2.i.i.i.i, i64 %4 ; [#uses = 3, type = i8*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 3]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i.i.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i.i.i.i.i = icmp ule i8* %.ptr2.i.i.i.i, %5 ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i.i.i.i.i = and i1 %.not.i.i.i.i.i, %10 ; [#uses = 1]
  %11 = ptrtoint i8* %.ptr2.i.i.i.i to i64        ; [#uses = 1]
  br i1 %andandval.i.i.i.i.i, label %if.i.i.i.i.i, label %endif.i.i.i.i.i

if.i.i.i.i.i:                                     ; preds = %0
  %12 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i.i to i64 ; [#uses = 1]
  %13 = ptrtoint { i64, i32* }* %source to i64    ; [#uses = 1]
  %14 = sub i64 %12, %13                          ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i

endif.i.i.i.i.i:                                  ; preds = %0
  %.not28.i.i.i.i.i = icmp uge i8* %.ptr2.i.i.i.i, %5 ; [#uses = 1]
  %17 = icmp ult i8* %.ptr2.i.i.i.i, %8           ; [#uses = 1]
  %andandval17.i.i.i.i.i = and i1 %.not28.i.i.i.i.i, %17 ; [#uses = 1]
  br i1 %andandval17.i.i.i.i.i, label %if18.i.i.i.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i

if18.i.i.i.i.i:                                   ; preds = %endif.i.i.i.i.i
  %18 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i.i to i64 ; [#uses = 1]
  %19 = sub i64 %18, %11                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2.i.i.i.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i: ; preds = %if18.i.i.i.i.i, %endif.i.i.i.i.i, %if.i.i.i.i.i
  %22 = phi { i64, i8* } [ %16, %if.i.i.i.i.i ], [ %21, %if18.i.i.i.i.i ], [ zeroinitializer, %endif.i.i.i.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i.i.i.i = extractvalue { i64, i8* } %22, 0 ; [#uses = 1]
  %.not.i.i.i = icmp eq i64 %.len1.i.i.i.i, 0     ; [#uses = 1]
  br i1 %.not.i.i.i, label %_D3std9algorithm8mutation__T8moveImplTAiZQnFNaNbNiNfMNkKQsZQv.exit, label %assertFailed.i.i.i

assertFailed.i.i.i:                               ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.38, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 1429) #5
  unreachable

_D3std9algorithm8mutation__T8moveImplTAiZQnFNaNbNiNfMNkKQsZQv.exit: ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i.i
  %.fca.0.insert.i.i = insertvalue { i64, i32* } undef, i64 %.len.i.i.i.i, 0 ; [#uses = 1]
  %23 = bitcast i8* %.ptr2.i.i.i.i to i32*        ; [#uses = 1]
  %.fca.1.insert6.i.i = insertvalue { i64, i32* } %.fca.0.insert.i.i, i32* %23, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert6.i.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm11__xopEqualsFKxSQDtQDs__TQDpTQDfVQDga5_61203c2062VQDgi0ZQEuKxQBuZb(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %q, %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %p) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %p, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 3]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %p, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %1 = bitcast i32** %.elt1 to i8**               ; [#uses = 1]
  %.unpack27 = load i8*, i8** %1, align 8         ; [#uses = 1]
  %.elt3 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %q, i64 0, i32 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack4 = load i64, i64* %.elt3, align 8      ; [#uses = 1]
  %.elt5 = getelementptr inbounds %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %q, i64 0, i32 0, i32 1 ; [#uses = 1, type = i32**]
  %2 = bitcast i32** %.elt5 to i8**               ; [#uses = 1]
  %.unpack68 = load i8*, i8** %2, align 8         ; [#uses = 1]
  %.not.i = icmp eq i64 %.unpack, %.unpack4       ; [#uses = 1]
  br i1 %.not.i, label %endif.i, label %_D4core8internal5array8equality__T8__equalsTiTiZQoFNaNbNiNeMxAiMxQeZb.exit

endif.i:                                          ; preds = %0
  %3 = icmp eq i64 %.unpack, 0                    ; [#uses = 1]
  br i1 %3, label %_D4core8internal5array8equality__T8__equalsTiTiZQoFNaNbNiNeMxAiMxQeZb.exit, label %oror.i

oror.i:                                           ; preds = %endif.i
  %4 = shl i64 %.unpack, 2                        ; [#uses = 1]
  %bcmp.i = tail call i32 @bcmp(i8* %.unpack27, i8* %.unpack68, i64 %4) ; [#uses = 1]
  %5 = icmp eq i32 %bcmp.i, 0                     ; [#uses = 1]
  br label %_D4core8internal5array8equality__T8__equalsTiTiZQoFNaNbNiNeMxAiMxQeZb.exit

_D4core8internal5array8equality__T8__equalsTiTiZQoFNaNbNiNeMxAiMxQeZb.exit: ; preds = %0, %endif.i, %oror.i
  %merge.i = phi i1 [ false, %0 ], [ true, %endif.i ], [ %5, %oror.i ] ; [#uses = 1, type = i1]
  ret i1 %merge.i
}

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5range__T11SortedRangeTAiVAyaa5_61203c2062VEQBwQBv18SortedRangeOptionsi0ZQCm9__xtoHashFNbNeKxSQDuQDt__TQDqTQDgVQDha5_61203c2062VQDhi0ZQEvZm(%"std.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %p) local_unnamed_addr #0 {
unrolledstmt:
  %0 = load [19 x i8*]*, [19 x i8*]** getelementptr inbounds (%object.TypeInfo_Const, %object.TypeInfo_Const* @_D12TypeInfo_xAi6__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.range.SortedRange!(int[], \22a < b\22, SortedRangeOptions.assumeSorted).SortedRange"* %p to i8* ; [#uses = 1]
  %4 = tail call i64 %2(%object.TypeInfo_Const* nonnull @_D12TypeInfo_xAi6__initZ, i8* nonnull %3) ; [#uses = 1]
  ret i64 %4
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62Z__TQBvTiTiZQCdFNaNbNiNfKiKiZb(i32* dereferenceable(4) %__b, i32* dereferenceable(4) %__a) local_unnamed_addr #0 {
  %1 = load i32, i32* %__a, align 4               ; [#uses = 1]
  %2 = load i32, i32* %__b, align 4               ; [#uses = 1]
  %3 = icmp slt i32 %1, %2                        ; [#uses = 1]
  ret i1 %3
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 11]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 5]
  %1 = icmp ult i64 %r_arg.fca.0.extract, 2       ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, %_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv.exit, %0
  ret void

endif:                                            ; preds = %0
  %2 = lshr i64 %r_arg.fca.0.extract, 1           ; [#uses = 2]
  %.not7.i = icmp eq i64 %2, 0                    ; [#uses = 1]
  br i1 %.not7.i, label %forbody.i.i.preheader, label %forbody.i

forbody.i:                                        ; preds = %endif, %forbody.i
  %.in.i = phi i64 [ %3, %forbody.i ], [ %2, %endif ] ; [#uses = 1, type = i64]
  %3 = add nsw i64 %.in.i, -1                     ; [#uses = 3]
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T8siftDownZQkFNaNbNiNfQBbmymZv(i64 %r_arg.fca.0.extract, i64 %3, { i64, i32* } %r_arg) #1
  %.not.i = icmp eq i64 %3, 0                     ; [#uses = 1]
  br i1 %.not.i, label %endfor.i, label %forbody.i

endfor.i:                                         ; preds = %forbody.i
  %4 = icmp ugt i64 %r_arg.fca.0.extract, 1       ; [#uses = 1]
  br i1 %4, label %forbody.i.i.preheader, label %_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv.exit

forbody.i.i.preheader:                            ; preds = %endif, %endfor.i
  br label %forbody.i.i

forbody.i.i:                                      ; preds = %forbody.i.i.preheader, %endif.i.i
  %parent.018.i.i = phi i64 [ %12, %endif.i.i ], [ 0, %forbody.i.i.preheader ] ; [#uses = 4, type = i64]
  %__key169.017.i.i = phi i64 [ %13, %endif.i.i ], [ 1, %forbody.i.i.preheader ] ; [#uses = 3, type = i64]
  %bounds.cmp.i.i = icmp ult i64 %parent.018.i.i, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp.i.i, label %bounds.ok4.i.i, label %bounds.fail.i.i

bounds.ok4.i.i:                                   ; preds = %forbody.i.i
  %5 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.018.i.i ; [#uses = 1, type = i32*]
  %6 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %__key169.017.i.i ; [#uses = 1, type = i32*]
  %7 = load i32, i32* %5, align 4                 ; [#uses = 1]
  %8 = load i32, i32* %6, align 4                 ; [#uses = 1]
  %9 = icmp slt i32 %7, %8                        ; [#uses = 1]
  br i1 %9, label %assertFailed.i, label %endif.i.i

endif.i.i:                                        ; preds = %bounds.ok4.i.i
  %10 = and i64 %__key169.017.i.i, 1              ; [#uses = 1]
  %11 = xor i64 %10, 1                            ; [#uses = 1]
  %12 = add i64 %11, %parent.018.i.i              ; [#uses = 1]
  %13 = add nuw i64 %__key169.017.i.i, 1          ; [#uses = 2]
  %exitcond.not.i.i = icmp eq i64 %13, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not.i.i, label %_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv.exit, label %forbody.i.i

bounds.fail.i.i:                                  ; preds = %forbody.i.i
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2247, i64 %parent.018.i.i, i64 %r_arg.fca.0.extract) #5
  unreachable

assertFailed.i:                                   ; preds = %bounds.ok4.i.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 15, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.17, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2239) #5
  unreachable

_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv.exit: ; preds = %endif.i.i, %endfor.i
  %i.017 = add i64 %r_arg.fca.0.extract, -1       ; [#uses = 2]
  %.not18 = icmp eq i64 %i.017, 0                 ; [#uses = 1]
  br i1 %.not18, label %if, label %forbody.lr.ph

forbody.lr.ph:                                    ; preds = %_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv.exit
  %bounds.cmp.i.not = icmp eq i64 %r_arg.fca.0.extract, 0 ; [#uses = 1]
  br i1 %bounds.cmp.i.not, label %bounds.fail.i.split, label %forbody

forbody:                                          ; preds = %forbody.lr.ph, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit
  %i.019 = phi i64 [ %i.0, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %i.017, %forbody.lr.ph ] ; [#uses = 5, type = i64]
  %bounds.cmp2.i = icmp ugt i64 %r_arg.fca.0.extract, %i.019 ; [#uses = 1]
  br i1 %bounds.cmp2.i, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %bounds.fail4.i

bounds.fail4.i:                                   ; preds = %forbody
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %i.019, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail.i.split:                              ; preds = %forbody.lr.ph
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 0, i64 0) #5
  unreachable

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %forbody
  %14 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %i.019 ; [#uses = 2, type = i32*]
  %15 = load i32, i32* %r_arg.fca.1.extract, align 4 ; [#uses = 1]
  %16 = load i32, i32* %14, align 4               ; [#uses = 1]
  store i32 %16, i32* %r_arg.fca.1.extract, align 4
  store i32 %15, i32* %14, align 4
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %i.019, i64 0, { i64, i32* } %r_arg) #1
  %i.0 = add i64 %i.019, -1                       ; [#uses = 2]
  %.not = icmp eq i64 %i.0, 0                     ; [#uses = 1]
  br i1 %.not, label %if, label %forbody
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDbFNaNbNiNfQpZm({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %.lval_copy_for_ImplicitByvalRewrite = alloca { i64, i32* }, align 8 ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 7]
  %1 = lshr i64 %r_arg.fca.0.extract, 1           ; [#uses = 6]
  %2 = icmp ult i64 %r_arg.fca.0.extract, 512     ; [#uses = 1]
  br i1 %2, label %if, label %endif

if:                                               ; preds = %0
  %3 = icmp ugt i64 %r_arg.fca.0.extract, 31      ; [#uses = 1]
  br i1 %3, label %if3, label %endif4

if3:                                              ; preds = %if
  %4 = add nsw i64 %r_arg.fca.0.extract, -1       ; [#uses = 1]
  tail call void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmZQFiFNaNbNiNfQvmmmZv(i64 %4, i64 %1, i64 0, { i64, i32* } %r_arg) #1
  br label %endif4

endif4:                                           ; preds = %if3, %if
  ret i64 %1

endif:                                            ; preds = %0
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 1]
  %5 = lshr i64 %r_arg.fca.0.extract, 2           ; [#uses = 2]
  %r.sroa.0.0..sroa_idx = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r.sroa.0.0..sroa_idx, align 8
  %r.sroa.8.0..sroa_idx17 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 1 ; [#uses = 1, type = i32**]
  store i32* %r_arg.fca.1.extract, i32** %r.sroa.8.0..sroa_idx17, align 8
  %6 = sub nsw i64 %1, %5                         ; [#uses = 1]
  %7 = add nuw i64 %1, %5                         ; [#uses = 1]
  %8 = add i64 %r_arg.fca.0.extract, -1           ; [#uses = 1]
  tail call void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmTmTmZQFmFNaNbNiNfQzmmmmmZv(i64 %8, i64 %7, i64 %1, i64 %6, i64 0, { i64, i32* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #1
  ret i64 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv(i64 %i2_arg, i64 %i1_arg, { i64, i32* }* dereferenceable(16) %r) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %r, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 4]
  %bounds.cmp = icmp ugt i64 %.len, %i1_arg       ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %0
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %r, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr = load i32*, i32** %2, align 8            ; [#uses = 2]
  %bounds.cmp2 = icmp ugt i64 %.len, %i2_arg      ; [#uses = 1]
  br i1 %bounds.cmp2, label %bounds.ok3, label %bounds.fail4

bounds.ok3:                                       ; preds = %bounds.ok
  %3 = getelementptr inbounds i32, i32* %.ptr, i64 %i1_arg ; [#uses = 2, type = i32*]
  %4 = getelementptr inbounds i32, i32* %.ptr, i64 %i2_arg ; [#uses = 2, type = i32*]
  %5 = load i32, i32* %3, align 4                 ; [#uses = 1]
  %6 = load i32, i32* %4, align 4                 ; [#uses = 1]
  store i32 %6, i32* %3, align 4
  store i32 %5, i32* %4, align 4
  ret void

bounds.fail4:                                     ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %i2_arg, i64 %.len) #5
  unreachable

bounds.fail:                                      ; preds = %0
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %i1_arg, i64 %.len) #5
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T4swapTAiZQjFNaNbNiNeKQpKQsZv({ i64, i32* }* dereferenceable(16) %rhs, { i64, i32* }* dereferenceable(16) %lhs) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %lhs, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len.i = load i64, i64* %1, align 8            ; [#uses = 2]
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %lhs, i64 0, i32 1 ; [#uses = 2, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2.i = load i8*, i8** %3, align 8           ; [#uses = 10]
  %4 = shl i64 %.len.i, 2                         ; [#uses = 1]
  %5 = bitcast { i64, i32* }* %lhs to i8*         ; [#uses = 8]
  %6 = getelementptr inbounds i8, i8* %.ptr2.i, i64 %4 ; [#uses = 6, type = i8*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %lhs, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 6]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i.i = icmp ule i8* %.ptr2.i, %5           ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i.i = and i1 %.not.i.i, %10          ; [#uses = 1]
  %11 = ptrtoint i8* %.ptr2.i to i64              ; [#uses = 3]
  br i1 %andandval.i.i, label %if.i.i, label %endif.i.i

if.i.i:                                           ; preds = %0
  %12 = ptrtoint i8* %b_arg.a_arg.i.i.i to i64    ; [#uses = 1]
  %13 = ptrtoint { i64, i32* }* %lhs to i64       ; [#uses = 1]
  %14 = sub i64 %12, %13                          ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

endif.i.i:                                        ; preds = %0
  %.not28.i.i = icmp uge i8* %.ptr2.i, %5         ; [#uses = 1]
  %17 = icmp ult i8* %.ptr2.i, %8                 ; [#uses = 1]
  %andandval17.i.i = and i1 %.not28.i.i, %17      ; [#uses = 1]
  br i1 %andandval17.i.i, label %if18.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

if18.i.i:                                         ; preds = %endif.i.i
  %18 = ptrtoint i8* %b_arg.a_arg.i.i.i to i64    ; [#uses = 1]
  %19 = sub i64 %18, %11                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit: ; preds = %if.i.i, %endif.i.i, %if18.i.i
  %22 = phi { i64, i8* } [ %16, %if.i.i ], [ %21, %if18.i.i ], [ zeroinitializer, %endif.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i = extractvalue { i64, i8* } %22, 0     ; [#uses = 1]
  %.not = icmp eq i64 %.len1.i, 0                 ; [#uses = 1]
  br i1 %.not, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit
  %23 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %rhs, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len.i37 = load i64, i64* %23, align 8         ; [#uses = 2]
  %24 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %rhs, i64 0, i32 1 ; [#uses = 2, type = i32**]
  %25 = bitcast i32** %24 to i8**                 ; [#uses = 1]
  %.ptr2.i38 = load i8*, i8** %25, align 8        ; [#uses = 10]
  %26 = shl i64 %.len.i37, 2                      ; [#uses = 1]
  %27 = bitcast { i64, i32* }* %rhs to i8*        ; [#uses = 8]
  %28 = getelementptr inbounds i8, i8* %.ptr2.i38, i64 %26 ; [#uses = 6, type = i8*]
  %29 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %rhs, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %30 = bitcast { i64, i32* }* %29 to i8*         ; [#uses = 6]
  %31 = icmp ugt i8* %28, %30                     ; [#uses = 1]
  %b_arg.a_arg.i.i.i39 = select i1 %31, i8* %30, i8* %28 ; [#uses = 2]
  %.not.i.i40 = icmp ule i8* %.ptr2.i38, %27      ; [#uses = 1]
  %32 = icmp ugt i8* %28, %27                     ; [#uses = 1]
  %andandval.i.i41 = and i1 %.not.i.i40, %32      ; [#uses = 1]
  %33 = ptrtoint i8* %.ptr2.i38 to i64            ; [#uses = 3]
  br i1 %andandval.i.i41, label %if.i.i42, label %endif.i.i45

if.i.i42:                                         ; preds = %assertPassed
  %34 = ptrtoint i8* %b_arg.a_arg.i.i.i39 to i64  ; [#uses = 1]
  %35 = ptrtoint { i64, i32* }* %rhs to i64       ; [#uses = 1]
  %36 = sub i64 %34, %35                          ; [#uses = 1]
  %37 = insertvalue { i64, i8* } undef, i64 %36, 0 ; [#uses = 1]
  %38 = insertvalue { i64, i8* } %37, i8* %27, 1  ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48

endif.i.i45:                                      ; preds = %assertPassed
  %.not28.i.i43 = icmp uge i8* %.ptr2.i38, %27    ; [#uses = 1]
  %39 = icmp ult i8* %.ptr2.i38, %30              ; [#uses = 1]
  %andandval17.i.i44 = and i1 %.not28.i.i43, %39  ; [#uses = 1]
  br i1 %andandval17.i.i44, label %if18.i.i46, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48

if18.i.i46:                                       ; preds = %endif.i.i45
  %40 = ptrtoint i8* %b_arg.a_arg.i.i.i39 to i64  ; [#uses = 1]
  %41 = sub i64 %40, %33                          ; [#uses = 1]
  %42 = insertvalue { i64, i8* } undef, i64 %41, 0 ; [#uses = 1]
  %43 = insertvalue { i64, i8* } %42, i8* %.ptr2.i38, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48: ; preds = %if.i.i42, %endif.i.i45, %if18.i.i46
  %44 = phi { i64, i8* } [ %38, %if.i.i42 ], [ %43, %if18.i.i46 ], [ zeroinitializer, %endif.i.i45 ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i47 = extractvalue { i64, i8* } %44, 0   ; [#uses = 1]
  %.not49 = icmp eq i64 %.len1.i47, 0             ; [#uses = 1]
  br i1 %.not49, label %assertPassed1, label %assertFailed2

assertPassed1:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48
  %45 = icmp ugt i8* %6, %30                      ; [#uses = 1]
  %b_arg.a_arg.i.i.i27 = select i1 %45, i8* %30, i8* %6 ; [#uses = 2]
  %.not.i.i28 = icmp ule i8* %.ptr2.i, %27        ; [#uses = 1]
  %46 = icmp ugt i8* %6, %27                      ; [#uses = 1]
  %andandval.i.i29 = and i1 %.not.i.i28, %46      ; [#uses = 1]
  br i1 %andandval.i.i29, label %if.i.i30, label %endif.i.i33

if.i.i30:                                         ; preds = %assertPassed1
  %47 = ptrtoint i8* %b_arg.a_arg.i.i.i27 to i64  ; [#uses = 1]
  %48 = ptrtoint { i64, i32* }* %rhs to i64       ; [#uses = 1]
  %49 = sub i64 %47, %48                          ; [#uses = 1]
  %50 = insertvalue { i64, i8* } undef, i64 %49, 0 ; [#uses = 1]
  %51 = insertvalue { i64, i8* } %50, i8* %27, 1  ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36

endif.i.i33:                                      ; preds = %assertPassed1
  %.not28.i.i31 = icmp uge i8* %.ptr2.i, %27      ; [#uses = 1]
  %52 = icmp ult i8* %.ptr2.i, %30                ; [#uses = 1]
  %andandval17.i.i32 = and i1 %.not28.i.i31, %52  ; [#uses = 1]
  br i1 %andandval17.i.i32, label %if18.i.i34, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36

if18.i.i34:                                       ; preds = %endif.i.i33
  %53 = ptrtoint i8* %b_arg.a_arg.i.i.i27 to i64  ; [#uses = 1]
  %54 = sub i64 %53, %11                          ; [#uses = 1]
  %55 = insertvalue { i64, i8* } undef, i64 %54, 0 ; [#uses = 1]
  %56 = insertvalue { i64, i8* } %55, i8* %.ptr2.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36: ; preds = %if.i.i30, %endif.i.i33, %if18.i.i34
  %57 = phi { i64, i8* } [ %51, %if.i.i30 ], [ %56, %if18.i.i34 ], [ zeroinitializer, %endif.i.i33 ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i35 = extractvalue { i64, i8* } %57, 0   ; [#uses = 1]
  %.not50 = icmp eq i64 %.len1.i35, 0             ; [#uses = 1]
  br i1 %.not50, label %assertPassed3, label %assertFailed4

assertPassed3:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36
  %58 = icmp ugt i8* %28, %8                      ; [#uses = 1]
  %b_arg.a_arg.i.i.i15 = select i1 %58, i8* %8, i8* %28 ; [#uses = 2]
  %.not.i.i16 = icmp ule i8* %.ptr2.i38, %5       ; [#uses = 1]
  %59 = icmp ugt i8* %28, %5                      ; [#uses = 1]
  %andandval.i.i17 = and i1 %.not.i.i16, %59      ; [#uses = 1]
  br i1 %andandval.i.i17, label %if.i.i18, label %endif.i.i21

if.i.i18:                                         ; preds = %assertPassed3
  %60 = ptrtoint i8* %b_arg.a_arg.i.i.i15 to i64  ; [#uses = 1]
  %61 = ptrtoint { i64, i32* }* %lhs to i64       ; [#uses = 1]
  %62 = sub i64 %60, %61                          ; [#uses = 1]
  %63 = insertvalue { i64, i8* } undef, i64 %62, 0 ; [#uses = 1]
  %64 = insertvalue { i64, i8* } %63, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24

endif.i.i21:                                      ; preds = %assertPassed3
  %.not28.i.i19 = icmp uge i8* %.ptr2.i38, %5     ; [#uses = 1]
  %65 = icmp ult i8* %.ptr2.i38, %8               ; [#uses = 1]
  %andandval17.i.i20 = and i1 %.not28.i.i19, %65  ; [#uses = 1]
  br i1 %andandval17.i.i20, label %if18.i.i22, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24

if18.i.i22:                                       ; preds = %endif.i.i21
  %66 = ptrtoint i8* %b_arg.a_arg.i.i.i15 to i64  ; [#uses = 1]
  %67 = sub i64 %66, %33                          ; [#uses = 1]
  %68 = insertvalue { i64, i8* } undef, i64 %67, 0 ; [#uses = 1]
  %69 = insertvalue { i64, i8* } %68, i8* %.ptr2.i38, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24: ; preds = %if.i.i18, %endif.i.i21, %if18.i.i22
  %70 = phi { i64, i8* } [ %64, %if.i.i18 ], [ %69, %if18.i.i22 ], [ zeroinitializer, %endif.i.i21 ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i23 = extractvalue { i64, i8* } %70, 0   ; [#uses = 1]
  %.not51 = icmp eq i64 %.len1.i23, 0             ; [#uses = 1]
  br i1 %.not51, label %assertPassed5, label %assertFailed6

assertPassed5:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24
  %71 = bitcast i32** %2 to i64*                  ; [#uses = 1]
  %72 = bitcast i32** %24 to i64*                 ; [#uses = 1]
  store i64 %.len.i37, i64* %1, align 8
  store i64 %33, i64* %71, align 8
  store i64 %.len.i, i64* %23, align 8
  store i64 %11, i64* %72, align 8
  ret void

assertFailed6:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit24
  tail call void @_d_assert_msg({ i64, i8* } { i64 24, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.28, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 2831) #5
  unreachable

assertFailed4:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit36
  tail call void @_d_assert_msg({ i64, i8* } { i64 24, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.27, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 2830) #5
  unreachable

assertFailed2:                                    ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit48
  tail call void @_d_assert_msg({ i64, i8* } { i64 27, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.26, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 2829) #5
  unreachable

assertFailed:                                     ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit
  tail call void @_d_assert_msg({ i64, i8* } { i64 27, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.25, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 2828) #5
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQDcFNaNbNiNfQpZv({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 11]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 22]
  switch i64 %r_arg.fca.0.extract, label %bounds.ok137 [
    i64 0, label %case1
    i64 1, label %case1
    i64 2, label %bounds.ok5
    i64 3, label %bounds.ok17
    i64 4, label %bounds.ok81
  ]

case1:                                            ; preds = %endif164, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262, %bounds.ok62, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit246, %bounds.ok37, %0, %0, %bounds.ok137, %bounds.ok124, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit214, %bounds.ok5, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit
  ret void

bounds.ok5:                                       ; preds = %0
  %1 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 1 ; [#uses = 2, type = i32*]
  %2 = load i32, i32* %1, align 4                 ; [#uses = 2]
  %3 = load i32, i32* %r_arg.fca.1.extract, align 4 ; [#uses = 2]
  %4 = icmp slt i32 %2, %3                        ; [#uses = 1]
  br i1 %4, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %case1

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok5
  store i32 %2, i32* %r_arg.fca.1.extract, align 4
  store i32 %3, i32* %1, align 4
  br label %case1

bounds.ok17:                                      ; preds = %0
  %5 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 2 ; [#uses = 4, type = i32*]
  %6 = load i32, i32* %5, align 4                 ; [#uses = 7]
  %7 = load i32, i32* %r_arg.fca.1.extract, align 4 ; [#uses = 6]
  %8 = icmp slt i32 %6, %7                        ; [#uses = 1]
  %9 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 1 ; [#uses = 5, type = i32*]
  %10 = load i32, i32* %9, align 4                ; [#uses = 8]
  br i1 %8, label %bounds.ok29, label %bounds.ok49

bounds.ok29:                                      ; preds = %bounds.ok17
  %11 = icmp slt i32 %7, %10                      ; [#uses = 1]
  br i1 %11, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230, label %bounds.ok37

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230: ; preds = %bounds.ok29
  store i32 %7, i32* %9, align 4
  store i32 %6, i32* %r_arg.fca.1.extract, align 4
  store i32 %10, i32* %5, align 4
  br label %case1

bounds.ok37:                                      ; preds = %bounds.ok29
  store i32 %6, i32* %r_arg.fca.1.extract, align 4
  store i32 %7, i32* %5, align 4
  %12 = icmp slt i32 %10, %6                      ; [#uses = 1]
  br i1 %12, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit246, label %case1

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit246: ; preds = %bounds.ok37
  store i32 %10, i32* %r_arg.fca.1.extract, align 4
  store i32 %6, i32* %9, align 4
  br label %case1

bounds.ok49:                                      ; preds = %bounds.ok17
  %13 = icmp slt i32 %10, %7                      ; [#uses = 1]
  br i1 %13, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254, label %bounds.ok62

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254: ; preds = %bounds.ok49
  store i32 %10, i32* %r_arg.fca.1.extract, align 4
  store i32 %7, i32* %9, align 4
  br label %case1

bounds.ok62:                                      ; preds = %bounds.ok49
  %14 = icmp slt i32 %6, %10                      ; [#uses = 1]
  br i1 %14, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262, label %case1

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262: ; preds = %bounds.ok62
  store i32 %6, i32* %9, align 4
  store i32 %10, i32* %5, align 4
  br label %case1

bounds.ok81:                                      ; preds = %0
  %15 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 1 ; [#uses = 4, type = i32*]
  %16 = load i32, i32* %15, align 4               ; [#uses = 4]
  %17 = load i32, i32* %r_arg.fca.1.extract, align 4 ; [#uses = 4]
  %18 = icmp slt i32 %16, %17                     ; [#uses = 1]
  br i1 %18, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit270, label %bounds.ok88

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit270: ; preds = %bounds.ok81
  store i32 %16, i32* %r_arg.fca.1.extract, align 4
  store i32 %17, i32* %15, align 4
  br label %bounds.ok88

bounds.ok88:                                      ; preds = %bounds.ok81, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit270
  %19 = phi i32 [ %16, %bounds.ok81 ], [ %17, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit270 ] ; [#uses = 3, type = i32]
  %20 = phi i32 [ %17, %bounds.ok81 ], [ %16, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit270 ] ; [#uses = 3, type = i32]
  %21 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 3 ; [#uses = 3, type = i32*]
  %22 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 2 ; [#uses = 4, type = i32*]
  %23 = load i32, i32* %21, align 4               ; [#uses = 4]
  %24 = load i32, i32* %22, align 4               ; [#uses = 4]
  %25 = icmp slt i32 %23, %24                     ; [#uses = 1]
  br i1 %25, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit278, label %bounds.ok100

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit278: ; preds = %bounds.ok88
  store i32 %23, i32* %22, align 4
  store i32 %24, i32* %21, align 4
  br label %bounds.ok100

bounds.ok100:                                     ; preds = %bounds.ok88, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit278
  %26 = phi i32 [ %23, %bounds.ok88 ], [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit278 ] ; [#uses = 3, type = i32]
  %27 = phi i32 [ %24, %bounds.ok88 ], [ %23, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit278 ] ; [#uses = 3, type = i32]
  %28 = icmp slt i32 %27, %20                     ; [#uses = 1]
  br i1 %28, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit286, label %bounds.ok112

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit286: ; preds = %bounds.ok100
  store i32 %27, i32* %r_arg.fca.1.extract, align 4
  store i32 %20, i32* %22, align 4
  br label %bounds.ok112

bounds.ok112:                                     ; preds = %bounds.ok100, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit286
  %29 = phi i32 [ %27, %bounds.ok100 ], [ %20, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit286 ] ; [#uses = 2, type = i32]
  %30 = icmp slt i32 %26, %19                     ; [#uses = 1]
  br i1 %30, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit294, label %bounds.ok124

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit294: ; preds = %bounds.ok112
  store i32 %26, i32* %15, align 4
  store i32 %19, i32* %21, align 4
  br label %bounds.ok124

bounds.ok124:                                     ; preds = %bounds.ok112, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit294
  %31 = phi i32 [ %19, %bounds.ok112 ], [ %26, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit294 ] ; [#uses = 2, type = i32]
  %32 = icmp slt i32 %29, %31                     ; [#uses = 1]
  br i1 %32, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit214, label %case1

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit214: ; preds = %bounds.ok124
  store i32 %29, i32* %15, align 4
  store i32 %31, i32* %22, align 4
  br label %case1

bounds.ok137:                                     ; preds = %0
  %33 = add i64 %r_arg.fca.0.extract, -5          ; [#uses = 2]
  %lowerbound = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %33 ; [#uses = 1, type = i32*]
  %34 = insertvalue { i64, i32* } { i64 5, i32* undef }, i32* %lowerbound, 1 ; [#uses = 1]
  tail call void @_D3std9algorithm7sorting__T5sort5SQBg10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQCyFNaNbNiNfQpZv({ i64, i32* } %34) #1
  %35 = icmp eq i64 %r_arg.fca.0.extract, 5       ; [#uses = 1]
  br i1 %35, label %case1, label %bounds.ok155.preheader

bounds.ok155.preheader:                           ; preds = %bounds.ok137
  %36 = add i64 %r_arg.fca.0.extract, -6          ; [#uses = 1]
  %37 = add i64 %r_arg.fca.0.extract, -1          ; [#uses = 2]
  br label %bounds.ok155

bounds.ok155:                                     ; preds = %bounds.ok155.preheader, %forinc
  %38 = phi i64 [ %i.0335, %forinc ], [ %33, %bounds.ok155.preheader ] ; [#uses = 4, type = i64]
  %i.0335 = phi i64 [ %53, %forinc ], [ %36, %bounds.ok155.preheader ] ; [#uses = 4, type = i64]
  %39 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %i.0335 ; [#uses = 1, type = i32*]
  %40 = load i32, i32* %39, align 4               ; [#uses = 3]
  %bounds.cmp159 = icmp ult i64 %38, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp159, label %bounds.ok160, label %bounds.fail161

bounds.ok160:                                     ; preds = %bounds.ok155
  %41 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %38 ; [#uses = 1, type = i32*]
  %42 = load i32, i32* %41, align 4               ; [#uses = 2]
  %43 = icmp slt i32 %42, %40                     ; [#uses = 1]
  br i1 %43, label %bounds.ok167, label %endif164

bounds.ok167:                                     ; preds = %bounds.ok160, %bounds.ok178
  %44 = phi i32 [ %49, %bounds.ok178 ], [ %42, %bounds.ok160 ] ; [#uses = 1, type = i32]
  %j.0 = phi i64 [ %47, %bounds.ok178 ], [ %38, %bounds.ok160 ] ; [#uses = 4, type = i64]
  %45 = add i64 %j.0, -1                          ; [#uses = 3]
  %bounds.cmp171 = icmp ult i64 %45, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp171, label %bounds.ok172, label %bounds.fail173

bounds.ok172:                                     ; preds = %bounds.ok167
  %46 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %45 ; [#uses = 1, type = i32*]
  store i32 %44, i32* %46, align 4
  %47 = add i64 %j.0, 1                           ; [#uses = 2]
  %exitcond.not = icmp eq i64 %j.0, %37           ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.ok183, label %bounds.ok178

bounds.fail173:                                   ; preds = %bounds.ok167
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1753, i64 %45, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.ok178:                                     ; preds = %bounds.ok172
  %48 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %47 ; [#uses = 1, type = i32*]
  %49 = load i32, i32* %48, align 4               ; [#uses = 2]
  %50 = icmp slt i32 %49, %40                     ; [#uses = 1]
  br i1 %50, label %bounds.ok167, label %bounds.ok183

bounds.ok183:                                     ; preds = %bounds.ok172, %bounds.ok178
  %j.0.lcssa338 = phi i64 [ %j.0, %bounds.ok178 ], [ %37, %bounds.ok172 ] ; [#uses = 1, type = i64]
  %51 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %j.0.lcssa338 ; [#uses = 1, type = i32*]
  store i32 %40, i32* %51, align 4
  br label %endif164

endif164:                                         ; preds = %bounds.ok183, %bounds.ok160
  %52 = icmp eq i64 %i.0335, 0                    ; [#uses = 1]
  br i1 %52, label %case1, label %forinc

bounds.fail161:                                   ; preds = %bounds.ok155
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1748, i64 %38, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail156:                                   ; preds = %forinc
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1744, i64 %53, i64 %r_arg.fca.0.extract) #5
  unreachable

forinc:                                           ; preds = %endif164
  %53 = add i64 %i.0335, -1                       ; [#uses = 3]
  %bounds.cmp154 = icmp ult i64 %53, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp154, label %bounds.ok155, label %bounds.fail156
}

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

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

_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTiTmZQBbFNaNbNiNfKiKmZb.exit.thread: ; preds = %condend, %_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTiTmZQBbFNaNbNiNfKiKmZb.exit
  br label %3

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std10functional__T6safeOpVAyaa1_3cZ__TQuTiTmZQBbFNaNbNiNfKiKmZb(i64* dereferenceable(8) %b, i32* dereferenceable(4) %a) local_unnamed_addr #0 {
  %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__T8unsafeOpTiTmZQoFNaNbNiNfimZb(i64 %b_arg, i32 %a_arg) local_unnamed_addr #0 {
  %1 = sext i32 %a_arg to i64                     ; [#uses = 1]
  %2 = icmp ult i64 %1, %b_arg                    ; [#uses = 1]
  ret i1 %2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9buildHeapZQlFNaNbNiNfQBcZv({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 6]
  %1 = lshr i64 %r_arg.fca.0.extract, 1           ; [#uses = 2]
  %.not7 = icmp eq i64 %1, 0                      ; [#uses = 1]
  br i1 %.not7, label %endfor, label %forbody

forbody:                                          ; preds = %0, %forbody
  %.in = phi i64 [ %2, %forbody ], [ %1, %0 ]     ; [#uses = 1, type = i64]
  %2 = add nsw i64 %.in, -1                       ; [#uses = 3]
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T8siftDownZQkFNaNbNiNfQBbmymZv(i64 %r_arg.fca.0.extract, i64 %2, { i64, i32* } %r_arg) #1
  %.not = icmp eq i64 %2, 0                       ; [#uses = 1]
  br i1 %.not, label %endfor, label %forbody

endfor:                                           ; preds = %forbody, %0
  %r_arg.fca.1.extract.i = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 2]
  %3 = icmp ugt i64 %r_arg.fca.0.extract, 1       ; [#uses = 1]
  br i1 %3, label %forbody.i, label %assertPassed

forbody.i:                                        ; preds = %endfor, %endif.i
  %parent.018.i = phi i64 [ %11, %endif.i ], [ 0, %endfor ] ; [#uses = 4, type = i64]
  %__key169.017.i = phi i64 [ %12, %endif.i ], [ 1, %endfor ] ; [#uses = 3, type = i64]
  %bounds.cmp.i = icmp ult i64 %parent.018.i, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp.i, label %bounds.ok4.i, label %bounds.fail.i

bounds.ok4.i:                                     ; preds = %forbody.i
  %4 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract.i, i64 %parent.018.i ; [#uses = 1, type = i32*]
  %5 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract.i, i64 %__key169.017.i ; [#uses = 1, type = i32*]
  %6 = load i32, i32* %4, align 4                 ; [#uses = 1]
  %7 = load i32, i32* %5, align 4                 ; [#uses = 1]
  %8 = icmp slt i32 %6, %7                        ; [#uses = 1]
  br i1 %8, label %assertFailed, label %endif.i

endif.i:                                          ; preds = %bounds.ok4.i
  %9 = and i64 %__key169.017.i, 1                 ; [#uses = 1]
  %10 = xor i64 %9, 1                             ; [#uses = 1]
  %11 = add i64 %10, %parent.018.i                ; [#uses = 1]
  %12 = add nuw i64 %__key169.017.i, 1            ; [#uses = 2]
  %exitcond.not.i = icmp eq i64 %12, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not.i, label %assertPassed, label %forbody.i

bounds.fail.i:                                    ; preds = %forbody.i
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2247, i64 %parent.018.i, i64 %r_arg.fca.0.extract) #5
  unreachable

assertPassed:                                     ; preds = %endif.i, %endfor
  ret void

assertFailed:                                     ; preds = %bounds.ok4.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 15, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.17, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2239) #5
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %end_arg, i64 %parent_arg, { i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 16]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 8]
  %1 = shl i64 %parent_arg, 1                     ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 3]
  %.not97 = icmp ult i64 %2, %end_arg             ; [#uses = 1]
  br i1 %.not97, label %endif, label %if

if:                                               ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61, %0
  %parent.0.lcssa = phi i64 [ %parent_arg, %0 ], [ %spec.select, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ] ; [#uses = 4, type = i64]
  %.lcssa82 = phi i64 [ %1, %0 ], [ %21, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ] ; [#uses = 1, type = i64]
  %.lcssa77 = phi i64 [ %2, %0 ], [ %22, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ] ; [#uses = 1, type = i64]
  %3 = icmp eq i64 %.lcssa77, %end_arg            ; [#uses = 1]
  br i1 %3, label %if1, label %endfor

if1:                                              ; preds = %if
  %4 = or i64 %.lcssa82, 1                        ; [#uses = 4]
  %bounds.cmp.i = icmp ugt i64 %r_arg.fca.0.extract, %parent.0.lcssa ; [#uses = 1]
  br i1 %bounds.cmp.i, label %bounds.ok.i, label %bounds.fail.i

bounds.ok.i:                                      ; preds = %if1
  %bounds.cmp2.i = icmp ugt i64 %r_arg.fca.0.extract, %4 ; [#uses = 1]
  br i1 %bounds.cmp2.i, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %bounds.fail4.i

bounds.fail4.i:                                   ; preds = %bounds.ok.i
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %4, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail.i:                                    ; preds = %if1
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %parent.0.lcssa, i64 %r_arg.fca.0.extract) #5
  unreachable

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok.i
  %5 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.0.lcssa ; [#uses = 2, type = i32*]
  %6 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %4 ; [#uses = 2, type = i32*]
  %7 = load i32, i32* %5, align 4                 ; [#uses = 1]
  %8 = load i32, i32* %6, align 4                 ; [#uses = 1]
  store i32 %8, i32* %5, align 4
  store i32 %7, i32* %6, align 4
  br label %endfor

endif:                                            ; preds = %0, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61
  %9 = phi i64 [ %22, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ], [ %2, %0 ] ; [#uses = 4, type = i64]
  %10 = phi i64 [ %21, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ], [ %1, %0 ] ; [#uses = 1, type = i64]
  %parent.098 = phi i64 [ %spec.select, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61 ], [ %parent_arg, %0 ] ; [#uses = 3, type = i64]
  %11 = or i64 %10, 1                             ; [#uses = 4]
  %bounds.cmp = icmp ult i64 %9, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %endif
  %bounds.cmp4 = icmp ult i64 %11, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp4, label %bounds.ok5, label %bounds.fail6

bounds.ok5:                                       ; preds = %bounds.ok
  %12 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %9 ; [#uses = 1, type = i32*]
  %13 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %11 ; [#uses = 1, type = i32*]
  %14 = load i32, i32* %12, align 4               ; [#uses = 1]
  %15 = load i32, i32* %13, align 4               ; [#uses = 1]
  %16 = icmp slt i32 %14, %15                     ; [#uses = 1]
  %spec.select = select i1 %16, i64 %11, i64 %9   ; [#uses = 6]
  %bounds.cmp.i55 = icmp ugt i64 %r_arg.fca.0.extract, %parent.098 ; [#uses = 1]
  br i1 %bounds.cmp.i55, label %bounds.ok.i58, label %bounds.fail.i60

bounds.ok.i58:                                    ; preds = %bounds.ok5
  %bounds.cmp2.i57 = icmp ugt i64 %r_arg.fca.0.extract, %spec.select ; [#uses = 1]
  br i1 %bounds.cmp2.i57, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61, label %bounds.fail4.i59

bounds.fail4.i59:                                 ; preds = %bounds.ok.i58
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %spec.select, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail.i60:                                  ; preds = %bounds.ok5
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 3105, i64 %parent.098, i64 %r_arg.fca.0.extract) #5
  unreachable

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit61: ; preds = %bounds.ok.i58
  %17 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.098 ; [#uses = 2, type = i32*]
  %18 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %spec.select ; [#uses = 2, type = i32*]
  %19 = load i32, i32* %17, align 4               ; [#uses = 1]
  %20 = load i32, i32* %18, align 4               ; [#uses = 1]
  store i32 %20, i32* %17, align 4
  store i32 %19, i32* %18, align 4
  %21 = shl i64 %spec.select, 1                   ; [#uses = 3]
  %22 = add i64 %21, 2                            ; [#uses = 3]
  %.not = icmp ult i64 %22, %end_arg              ; [#uses = 1]
  br i1 %.not, label %endif, label %if

bounds.fail6:                                     ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2307, i64 %11, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail:                                      ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2307, i64 %9, i64 %r_arg.fca.0.extract) #5
  unreachable

endfor:                                           ; preds = %if, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit
  %parent.1 = phi i64 [ %4, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %parent.0.lcssa, %if ] ; [#uses = 2, type = i64]
  %23 = icmp ugt i64 %parent.1, %parent_arg       ; [#uses = 1]
  br i1 %23, label %forbody12, label %endfor14

forbody12:                                        ; preds = %endfor, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit69
  %child10.096 = phi i64 [ %25, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit69 ], [ %parent.1, %endfor ] ; [#uses = 4, type = i64]
  %24 = add i64 %child10.096, -1                  ; [#uses = 1]
  %25 = lshr i64 %24, 1                           ; [#uses = 5]
  %bounds.cmp16 = icmp ult i64 %25, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp16, label %bounds.ok17, label %bounds.fail18

bounds.ok17:                                      ; preds = %forbody12
  %bounds.cmp21 = icmp ult i64 %child10.096, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

bounds.ok22:                                      ; preds = %bounds.ok17
  %26 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %25 ; [#uses = 2, type = i32*]
  %27 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %child10.096 ; [#uses = 2, type = i32*]
  %28 = load i32, i32* %26, align 4               ; [#uses = 2]
  %29 = load i32, i32* %27, align 4               ; [#uses = 2]
  %30 = icmp slt i32 %28, %29                     ; [#uses = 1]
  br i1 %30, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit69, label %endfor14

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit69: ; preds = %bounds.ok22
  store i32 %29, i32* %26, align 4
  store i32 %28, i32* %27, align 4
  %31 = icmp ugt i64 %25, %parent_arg             ; [#uses = 1]
  br i1 %31, label %forbody12, label %endfor14

bounds.fail23:                                    ; preds = %bounds.ok17
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2316, i64 %child10.096, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail18:                                    ; preds = %forbody12
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2316, i64 %25, i64 %r_arg.fca.0.extract) #5
  unreachable

endfor14:                                         ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit69, %bounds.ok22, %endfor
  ret void
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T8siftDownZQkFNaNbNiNfQBbmymZv(i64 %end_arg, i64 %parent_arg, { i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 12]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 6]
  %1 = shl i64 %parent_arg, 1                     ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 3]
  %.not91 = icmp ult i64 %2, %end_arg             ; [#uses = 1]
  br i1 %.not91, label %endif, label %if

if:                                               ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, %0
  %parent.0.lcssa = phi i64 [ %parent_arg, %0 ], [ %spec.select, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ] ; [#uses = 3, type = i64]
  %.lcssa73 = phi i64 [ %1, %0 ], [ %23, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ] ; [#uses = 1, type = i64]
  %.lcssa = phi i64 [ %2, %0 ], [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ] ; [#uses = 1, type = i64]
  %3 = icmp eq i64 %.lcssa, %end_arg              ; [#uses = 1]
  br i1 %3, label %andand, label %endfor

andand:                                           ; preds = %if
  %bounds.cmp = icmp ult i64 %parent.0.lcssa, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %andand
  %4 = or i64 %.lcssa73, 1                        ; [#uses = 3]
  %bounds.cmp2 = icmp ult i64 %4, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp2, label %bounds.ok3, label %bounds.fail4

bounds.ok3:                                       ; preds = %bounds.ok
  %5 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.0.lcssa ; [#uses = 2, type = i32*]
  %6 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %4 ; [#uses = 2, type = i32*]
  %7 = load i32, i32* %5, align 4                 ; [#uses = 2]
  %8 = load i32, i32* %6, align 4                 ; [#uses = 2]
  %9 = icmp slt i32 %7, %8                        ; [#uses = 1]
  br i1 %9, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit63, label %endfor

bounds.fail4:                                     ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2265, i64 %4, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail:                                      ; preds = %andand
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2265, i64 %parent.0.lcssa, i64 %r_arg.fca.0.extract) #5
  unreachable

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit63: ; preds = %bounds.ok3
  store i32 %8, i32* %5, align 4
  store i32 %7, i32* %6, align 4
  br label %endfor

endif:                                            ; preds = %0, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit
  %10 = phi i64 [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %2, %0 ] ; [#uses = 4, type = i64]
  %11 = phi i64 [ %23, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %1, %0 ] ; [#uses = 1, type = i64]
  %parent.092 = phi i64 [ %spec.select, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit ], [ %parent_arg, %0 ] ; [#uses = 3, type = i64]
  %12 = or i64 %11, 1                             ; [#uses = 4]
  %bounds.cmp9 = icmp ult i64 %10, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp9, label %bounds.ok10, label %bounds.fail11

bounds.ok10:                                      ; preds = %endif
  %bounds.cmp14 = icmp ult i64 %12, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %bounds.ok10
  %13 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %10 ; [#uses = 1, type = i32*]
  %14 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %12 ; [#uses = 1, type = i32*]
  %15 = load i32, i32* %13, align 4               ; [#uses = 1]
  %16 = load i32, i32* %14, align 4               ; [#uses = 1]
  %17 = icmp slt i32 %15, %16                     ; [#uses = 1]
  %spec.select = select i1 %17, i64 %12, i64 %10  ; [#uses = 6]
  %bounds.cmp21 = icmp ult i64 %parent.092, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

bounds.ok22:                                      ; preds = %bounds.ok15
  %bounds.cmp26 = icmp ult i64 %spec.select, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp26, label %bounds.ok27, label %bounds.fail28

bounds.ok27:                                      ; preds = %bounds.ok22
  %18 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.092 ; [#uses = 2, type = i32*]
  %19 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %spec.select ; [#uses = 2, type = i32*]
  %20 = load i32, i32* %18, align 4               ; [#uses = 2]
  %21 = load i32, i32* %19, align 4               ; [#uses = 2]
  %22 = icmp slt i32 %20, %21                     ; [#uses = 1]
  br i1 %22, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %endfor

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok27
  store i32 %21, i32* %18, align 4
  store i32 %20, i32* %19, align 4
  %23 = shl i64 %spec.select, 1                   ; [#uses = 3]
  %24 = add i64 %23, 2                            ; [#uses = 3]
  %.not = icmp ult i64 %24, %end_arg              ; [#uses = 1]
  br i1 %.not, label %endif, label %if

bounds.fail28:                                    ; preds = %bounds.ok22
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2271, i64 %spec.select, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail23:                                    ; preds = %bounds.ok15
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2271, i64 %parent.092, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail16:                                    ; preds = %bounds.ok10
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2270, i64 %12, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail11:                                    ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2270, i64 %10, i64 %r_arg.fca.0.extract) #5
  unreachable

endfor:                                           ; preds = %bounds.ok27, %bounds.ok3, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit63, %if
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZ__T6isHeapZQiFNaNbNiNfQzZb({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 4]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 2]
  %1 = icmp ugt i64 %r_arg.fca.0.extract, 1       ; [#uses = 1]
  br i1 %1, label %forbody, label %if

forbody:                                          ; preds = %0, %endif
  %parent.018 = phi i64 [ %9, %endif ], [ 0, %0 ] ; [#uses = 4, type = i64]
  %__key169.017 = phi i64 [ %10, %endif ], [ 1, %0 ] ; [#uses = 3, type = i64]
  %bounds.cmp = icmp ult i64 %parent.018, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok4, label %bounds.fail

bounds.ok4:                                       ; preds = %forbody
  %2 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %parent.018 ; [#uses = 1, type = i32*]
  %3 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %__key169.017 ; [#uses = 1, type = i32*]
  %4 = load i32, i32* %2, align 4                 ; [#uses = 1]
  %5 = load i32, i32* %3, align 4                 ; [#uses = 1]
  %6 = icmp slt i32 %4, %5                        ; [#uses = 1]
  br i1 %6, label %if, label %endif

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

endif:                                            ; preds = %bounds.ok4
  %7 = and i64 %__key169.017, 1                   ; [#uses = 1]
  %8 = xor i64 %7, 1                              ; [#uses = 1]
  %9 = add i64 %8, %parent.018                    ; [#uses = 1]
  %10 = add nuw i64 %__key169.017, 1              ; [#uses = 2]
  %exitcond.not = icmp eq i64 %10, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %forbody

bounds.fail:                                      ; preds = %forbody
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 2247, i64 %parent.018, i64 %r_arg.fca.0.extract) #5
  unreachable
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmZQFiFNaNbNiNfQvmmmZv(i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 8]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 5]
  %1 = icmp ugt i64 %r_arg.fca.0.extract, 2       ; [#uses = 1]
  br i1 %1, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %0
  %.not = icmp eq i64 %_param_1_arg, %_param_2_arg ; [#uses = 1]
  br i1 %.not, label %assertFailed2, label %assertPassed1

assertPassed1:                                    ; preds = %assertPassed
  %.not127 = icmp ne i64 %_param_1_arg, %_param_3_arg ; [#uses = 1]
  %2 = icmp ne i64 %_param_2_arg, %_param_3_arg   ; [#uses = 1]
  %andandval = and i1 %2, %.not127                ; [#uses = 1]
  br i1 %andandval, label %assertPassed3, label %assertFailed4

assertPassed3:                                    ; preds = %assertPassed1
  %bounds.cmp = icmp ugt i64 %r_arg.fca.0.extract, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %assertPassed3
  %bounds.cmp7 = icmp ugt i64 %r_arg.fca.0.extract, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp7, label %bounds.ok8, label %bounds.fail9

bounds.ok8:                                       ; preds = %bounds.ok
  %3 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %_param_3_arg ; [#uses = 6, type = i32*]
  %4 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %_param_1_arg ; [#uses = 9, type = i32*]
  %5 = load i32, i32* %3, align 4                 ; [#uses = 4]
  %6 = load i32, i32* %4, align 4                 ; [#uses = 6]
  %7 = icmp slt i32 %5, %6                        ; [#uses = 1]
  %bounds.cmp17 = icmp ugt i64 %r_arg.fca.0.extract, %_param_2_arg ; [#uses = 2]
  br i1 %7, label %bounds.ok13, label %else

bounds.ok13:                                      ; preds = %bounds.ok8
  br i1 %bounds.cmp17, label %bounds.ok18, label %bounds.fail19

bounds.ok18:                                      ; preds = %bounds.ok13
  %8 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 4, type = i32*]
  %9 = load i32, i32* %8, align 4                 ; [#uses = 2]
  %10 = icmp slt i32 %6, %9                       ; [#uses = 1]
  br i1 %10, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit143, label %bounds.ok31

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit143: ; preds = %bounds.ok18
  store i32 %9, i32* %4, align 4
  store i32 %6, i32* %8, align 4
  %11 = load i32, i32* %4, align 4                ; [#uses = 1]
  %12 = load i32, i32* %3, align 4                ; [#uses = 1]
  store i32 %12, i32* %4, align 4
  store i32 %11, i32* %3, align 4
  br label %bounds.ok68

bounds.ok31:                                      ; preds = %bounds.ok18
  store i32 %5, i32* %4, align 4
  store i32 %6, i32* %3, align 4
  %13 = load i32, i32* %8, align 4                ; [#uses = 2]
  %14 = load i32, i32* %4, align 4                ; [#uses = 2]
  %15 = icmp slt i32 %13, %14                     ; [#uses = 1]
  br i1 %15, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit159, label %bounds.ok68

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit159: ; preds = %bounds.ok31
  store i32 %13, i32* %4, align 4
  store i32 %14, i32* %8, align 4
  br label %bounds.ok68

bounds.fail19:                                    ; preds = %bounds.ok13
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4272, i64 %_param_2_arg, i64 %r_arg.fca.0.extract) #5
  unreachable

else:                                             ; preds = %bounds.ok8
  br i1 %bounds.cmp17, label %bounds.ok43, label %bounds.fail39

bounds.ok43:                                      ; preds = %else
  %16 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 3, type = i32*]
  %17 = load i32, i32* %16, align 4               ; [#uses = 4]
  %18 = icmp slt i32 %17, %6                      ; [#uses = 1]
  br i1 %18, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit167, label %bounds.ok56

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit167: ; preds = %bounds.ok43
  store i32 %17, i32* %4, align 4
  store i32 %6, i32* %16, align 4
  br label %bounds.ok68

bounds.ok56:                                      ; preds = %bounds.ok43
  %19 = icmp slt i32 %5, %17                      ; [#uses = 1]
  br i1 %19, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %bounds.ok68

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok56
  store i32 %5, i32* %16, align 4
  store i32 %17, i32* %3, align 4
  br label %bounds.ok68

bounds.fail39:                                    ; preds = %else
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4285, i64 %_param_2_arg, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.ok68:                                      ; preds = %bounds.ok31, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit159, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit143, %bounds.ok56, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit167
  %20 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 1, type = i32*]
  %21 = load i32, i32* %20, align 4               ; [#uses = 2]
  %22 = load i32, i32* %4, align 4                ; [#uses = 1]
  %23 = icmp slt i32 %21, %22                     ; [#uses = 1]
  br i1 %23, label %assertFailed72, label %bounds.ok80

bounds.ok80:                                      ; preds = %bounds.ok68
  %24 = load i32, i32* %3, align 4                ; [#uses = 1]
  %25 = icmp slt i32 %24, %21                     ; [#uses = 1]
  br i1 %25, label %assertFailed84, label %assertPassed83

assertPassed83:                                   ; preds = %bounds.ok80
  ret void

assertFailed84:                                   ; preds = %bounds.ok80
  tail call void @_d_assert_msg({ i64, i8* } { i64 22, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4295) #5
  unreachable

assertFailed72:                                   ; preds = %bounds.ok68
  tail call void @_d_assert_msg({ i64, i8* } { i64 22, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4294) #5
  unreachable

bounds.fail9:                                     ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4270, i64 %_param_1_arg, i64 %r_arg.fca.0.extract) #5
  unreachable

bounds.fail:                                      ; preds = %assertPassed3
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4270, i64 %_param_3_arg, i64 %r_arg.fca.0.extract) #5
  unreachable

assertFailed4:                                    ; preds = %assertPassed1
  tail call void @_d_assert_msg({ i64, i8* } { i64 16, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.21, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4246) #5
  unreachable

assertFailed2:                                    ; preds = %assertPassed
  tail call void @_d_assert_msg({ i64, i8* } { i64 7, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4239) #5
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 48, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.19, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4223) #5
  unreachable
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsVEQDy8typecons__T4FlagVQCha9_6c65616e5269676874ZQBfi0TAiTmTmTmTmTmZQFmFNaNbNiNfQzmmmmmZv(i64 %_param_5_arg, i64 %_param_4_arg, i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i32* }* byval align 8 %r) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %r, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 11]
  %2 = icmp ugt i64 %.len, 4                      ; [#uses = 1]
  br i1 %2, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %0
  %.not = icmp eq i64 %_param_1_arg, %_param_2_arg ; [#uses = 1]
  br i1 %.not, label %assertFailed2, label %assertPassed1

assertPassed1:                                    ; preds = %assertPassed
  %.not160 = icmp ne i64 %_param_1_arg, %_param_3_arg ; [#uses = 1]
  %3 = icmp ne i64 %_param_2_arg, %_param_3_arg   ; [#uses = 1]
  %andandval = and i1 %3, %.not160                ; [#uses = 1]
  br i1 %andandval, label %assertPassed3, label %assertFailed4

assertPassed3:                                    ; preds = %assertPassed1
  %.not161 = icmp ne i64 %_param_1_arg, %_param_4_arg ; [#uses = 1]
  %4 = icmp ne i64 %_param_2_arg, %_param_4_arg   ; [#uses = 1]
  %andandval7 = and i1 %4, %.not161               ; [#uses = 1]
  %5 = icmp ne i64 %_param_3_arg, %_param_4_arg   ; [#uses = 1]
  %andandval10 = and i1 %5, %andandval7           ; [#uses = 1]
  br i1 %andandval10, label %assertPassed11, label %assertFailed12

assertPassed11:                                   ; preds = %assertPassed3
  %.not162 = icmp ne i64 %_param_1_arg, %_param_5_arg ; [#uses = 1]
  %6 = icmp ne i64 %_param_2_arg, %_param_5_arg   ; [#uses = 1]
  %andandval15 = and i1 %6, %.not162              ; [#uses = 1]
  %7 = icmp ne i64 %_param_3_arg, %_param_5_arg   ; [#uses = 1]
  %andandval18 = and i1 %7, %andandval15          ; [#uses = 1]
  %8 = icmp ne i64 %_param_4_arg, %_param_5_arg   ; [#uses = 1]
  %andandval21 = and i1 %8, %andandval18          ; [#uses = 1]
  br i1 %andandval21, label %assertPassed22, label %assertFailed23

assertPassed22:                                   ; preds = %assertPassed11
  %bounds.cmp = icmp ugt i64 %.len, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %assertPassed22
  %9 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %r, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr = load i32*, i32** %9, align 8            ; [#uses = 5]
  %bounds.cmp26 = icmp ugt i64 %.len, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp26, label %bounds.ok27, label %bounds.fail28

bounds.ok27:                                      ; preds = %bounds.ok
  %10 = getelementptr inbounds i32, i32* %.ptr, i64 %_param_3_arg ; [#uses = 9, type = i32*]
  %11 = getelementptr inbounds i32, i32* %.ptr, i64 %_param_1_arg ; [#uses = 6, type = i32*]
  %12 = load i32, i32* %10, align 4               ; [#uses = 3]
  %13 = load i32, i32* %11, align 4               ; [#uses = 3]
  %14 = icmp slt i32 %12, %13                     ; [#uses = 1]
  br i1 %14, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit170, label %endif

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit170: ; preds = %bounds.ok27
  store i32 %12, i32* %11, align 4
  store i32 %13, i32* %10, align 4
  br label %endif

endif:                                            ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit170, %bounds.ok27
  %15 = phi i32 [ %13, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit170 ], [ %12, %bounds.ok27 ] ; [#uses = 1, type = i32]
  %bounds.cmp31 = icmp ugt i64 %.len, %_param_4_arg ; [#uses = 1]
  br i1 %bounds.cmp31, label %bounds.ok32, label %bounds.fail33

bounds.ok32:                                      ; preds = %endif
  %bounds.cmp36 = icmp ugt i64 %.len, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

bounds.ok37:                                      ; preds = %bounds.ok32
  %16 = getelementptr inbounds i32, i32* %.ptr, i64 %_param_4_arg ; [#uses = 3, type = i32*]
  %17 = getelementptr inbounds i32, i32* %.ptr, i64 %_param_2_arg ; [#uses = 8, type = i32*]
  %18 = load i32, i32* %16, align 4               ; [#uses = 3]
  %19 = load i32, i32* %17, align 4               ; [#uses = 3]
  %20 = icmp slt i32 %18, %19                     ; [#uses = 1]
  br i1 %20, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit178, label %bounds.ok49

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit178: ; preds = %bounds.ok37
  store i32 %18, i32* %17, align 4
  store i32 %19, i32* %16, align 4
  %.pre = load i32, i32* %10, align 4             ; [#uses = 1]
  br label %bounds.ok49

bounds.ok49:                                      ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit178, %bounds.ok37
  %21 = phi i32 [ %.pre, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit178 ], [ %15, %bounds.ok37 ] ; [#uses = 2, type = i32]
  %22 = phi i32 [ %19, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit178 ], [ %18, %bounds.ok37 ] ; [#uses = 2, type = i32]
  %23 = icmp slt i32 %22, %21                     ; [#uses = 1]
  br i1 %23, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit194, label %endif53

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit194: ; preds = %bounds.ok49
  store i32 %22, i32* %10, align 4
  store i32 %21, i32* %16, align 4
  %24 = load i32, i32* %11, align 4               ; [#uses = 1]
  %25 = load i32, i32* %17, align 4               ; [#uses = 1]
  store i32 %25, i32* %11, align 4
  store i32 %24, i32* %17, align 4
  br label %endif53

endif53:                                          ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit194, %bounds.ok49
  %bounds.cmp55 = icmp ugt i64 %.len, %_param_5_arg ; [#uses = 1]
  br i1 %bounds.cmp55, label %bounds.ok61, label %bounds.fail57

bounds.ok61:                                      ; preds = %endif53
  %26 = getelementptr inbounds i32, i32* %.ptr, i64 %_param_5_arg ; [#uses = 3, type = i32*]
  %27 = load i32, i32* %26, align 4               ; [#uses = 3]
  %28 = load i32, i32* %17, align 4               ; [#uses = 3]
  %29 = icmp slt i32 %27, %28                     ; [#uses = 1]
  br i1 %29, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit202, label %bounds.ok73

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit202: ; preds = %bounds.ok61
  store i32 %27, i32* %17, align 4
  store i32 %28, i32* %26, align 4
  br label %bounds.ok73

bounds.ok73:                                      ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit202, %bounds.ok61
  %30 = phi i32 [ %28, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit202 ], [ %27, %bounds.ok61 ] ; [#uses = 2, type = i32]
  %31 = load i32, i32* %10, align 4               ; [#uses = 4]
  %32 = icmp slt i32 %30, %31                     ; [#uses = 1]
  br i1 %32, label %bounds.ok85, label %bounds.ok97

bounds.ok85:                                      ; preds = %bounds.ok73
  store i32 %30, i32* %10, align 4
  store i32 %31, i32* %26, align 4
  %33 = load i32, i32* %10, align 4               ; [#uses = 2]
  %34 = load i32, i32* %11, align 4               ; [#uses = 2]
  %35 = icmp slt i32 %33, %34                     ; [#uses = 1]
  br i1 %35, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit218, label %endif77

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit218: ; preds = %bounds.ok85
  store i32 %33, i32* %11, align 4
  store i32 %34, i32* %10, align 4
  br label %endif77

bounds.ok97:                                      ; preds = %bounds.ok73
  %36 = load i32, i32* %17, align 4               ; [#uses = 2]
  %37 = icmp slt i32 %31, %36                     ; [#uses = 1]
  br i1 %37, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %endif77

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok97
  store i32 %31, i32* %17, align 4
  store i32 %36, i32* %10, align 4
  br label %endif77

endif77:                                          ; preds = %bounds.ok97, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, %bounds.ok85, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit218
  ret void

bounds.fail57:                                    ; preds = %endif53
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4332, i64 %_param_5_arg, i64 %.len) #5
  unreachable

bounds.fail38:                                    ; preds = %bounds.ok32
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4326, i64 %_param_2_arg, i64 %.len) #5
  unreachable

bounds.fail33:                                    ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4326, i64 %_param_4_arg, i64 %.len) #5
  unreachable

bounds.fail28:                                    ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4325, i64 %_param_1_arg, i64 %.len) #5
  unreachable

bounds.fail:                                      ; preds = %assertPassed22
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4325, i64 %_param_3_arg, i64 %.len) #5
  unreachable

assertFailed23:                                   ; preds = %assertPassed11
  tail call void @_d_assert_msg({ i64, i8* } { i64 43, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.24, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4260) #5
  unreachable

assertFailed12:                                   ; preds = %assertPassed3
  tail call void @_d_assert_msg({ i64, i8* } { i64 33, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.23, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4253) #5
  unreachable

assertFailed4:                                    ; preds = %assertPassed1
  tail call void @_d_assert_msg({ i64, i8* } { i64 16, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.21, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4246) #5
  unreachable

assertFailed2:                                    ; preds = %assertPassed
  tail call void @_d_assert_msg({ i64, i8* } { i64 7, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4239) #5
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 48, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.19, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 4223) #5
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb({ i64, i32* }* dereferenceable(16) %target, { i64, i32* }* dereferenceable(16) %source) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2 = load i8*, i8** %3, align 8             ; [#uses = 6]
  %4 = shl i64 %.len, 2                           ; [#uses = 1]
  %5 = bitcast { i64, i32* }* %target to i8*      ; [#uses = 4]
  %6 = getelementptr inbounds i8, i8* %.ptr2, i64 %4 ; [#uses = 3, type = i8*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %target, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 3]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i = icmp ule i8* %.ptr2, %5               ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i = and i1 %.not.i, %10              ; [#uses = 1]
  br i1 %andandval.i, label %if.i, label %endif.i

if.i:                                             ; preds = %0
  %11 = ptrtoint i8* %b_arg.a_arg.i.i to i64      ; [#uses = 1]
  %12 = ptrtoint { i64, i32* }* %target to i64    ; [#uses = 1]
  %13 = sub i64 %11, %12                          ; [#uses = 1]
  %14 = insertvalue { i64, i8* } undef, i64 %13, 0 ; [#uses = 1]
  %15 = insertvalue { i64, i8* } %14, i8* %5, 1   ; [#uses = 1]
  br label %_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf.exit

endif.i:                                          ; preds = %0
  %.not28.i = icmp uge i8* %.ptr2, %5             ; [#uses = 1]
  %16 = icmp ult i8* %.ptr2, %8                   ; [#uses = 1]
  %andandval17.i = and i1 %.not28.i, %16          ; [#uses = 1]
  br i1 %andandval17.i, label %if18.i, label %_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf.exit

if18.i:                                           ; preds = %endif.i
  %17 = ptrtoint i8* %b_arg.a_arg.i.i to i64      ; [#uses = 1]
  %18 = ptrtoint i8* %.ptr2 to i64                ; [#uses = 1]
  %19 = sub i64 %17, %18                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2, 1 ; [#uses = 1]
  br label %_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf.exit

_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf.exit: ; preds = %endif.i, %if18.i, %if.i
  %22 = phi { i64, i8* } [ %15, %if.i ], [ %21, %if18.i ], [ zeroinitializer, %endif.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1 = extractvalue { i64, i8* } %22, 0       ; [#uses = 1]
  %23 = icmp ne i64 %.len1, 0                     ; [#uses = 1]
  ret i1 %23
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf({ i64, i8* } %b_arg, { i64, i8* } %a_arg) local_unnamed_addr #0 {
andandend:
  %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 = 6]
  %b_arg.fca.0.extract = extractvalue { i64, i8* } %b_arg, 0 ; [#uses = 1]
  %b_arg.fca.1.extract = extractvalue { i64, i8* } %b_arg, 1 ; [#uses = 6]
  %0 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %a_arg.fca.0.extract ; [#uses = 3, type = i8*]
  %1 = getelementptr inbounds i8, i8* %b_arg.fca.1.extract, i64 %b_arg.fca.0.extract ; [#uses = 3, type = i8*]
  %2 = icmp ult i8* %1, %0                        ; [#uses = 1]
  %b_arg.a_arg.i = select i1 %2, i8* %1, i8* %0   ; [#uses = 2]
  %.not = icmp ule i8* %a_arg.fca.1.extract, %b_arg.fca.1.extract ; [#uses = 1]
  %3 = icmp ult i8* %b_arg.fca.1.extract, %0      ; [#uses = 1]
  %andandval = and i1 %.not, %3                   ; [#uses = 1]
  br i1 %andandval, label %if, label %endif

if:                                               ; preds = %andandend
  %4 = ptrtoint i8* %b_arg.a_arg.i to i64         ; [#uses = 1]
  %5 = ptrtoint i8* %b_arg.fca.1.extract to i64   ; [#uses = 1]
  %6 = sub i64 %4, %5                             ; [#uses = 1]
  %7 = insertvalue { i64, i8* } undef, i64 %6, 0  ; [#uses = 1]
  %8 = insertvalue { i64, i8* } %7, i8* %b_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %8

endif:                                            ; preds = %andandend
  %.not28 = icmp ule i8* %b_arg.fca.1.extract, %a_arg.fca.1.extract ; [#uses = 1]
  %9 = icmp ult i8* %a_arg.fca.1.extract, %1      ; [#uses = 1]
  %andandval17 = and i1 %.not28, %9               ; [#uses = 1]
  br i1 %andandval17, label %if18, label %endif19

if18:                                             ; preds = %endif
  %10 = ptrtoint i8* %b_arg.a_arg.i to i64        ; [#uses = 1]
  %11 = ptrtoint i8* %a_arg.fca.1.extract to i64  ; [#uses = 1]
  %12 = sub i64 %10, %11                          ; [#uses = 1]
  %13 = insertvalue { i64, i8* } undef, i64 %12, 0 ; [#uses = 1]
  %14 = insertvalue { i64, i8* } %13, i8* %a_arg.fca.1.extract, 1 ; [#uses = 1]
  ret { i64, i8* } %14

endif19:                                          ; preds = %endif
  ret { i64, i8* } zeroinitializer
}

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T5sort5SQBg10functional__T9binaryFunVAyaa5_61203c2062VQra1_61VQza1_62ZQBsTAiZQCyFNaNbNiNfQpZv({ i64, i32* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.0.extract = extractvalue { i64, i32* } %r_arg, 0 ; [#uses = 1]
  %r_arg.fca.1.extract = extractvalue { i64, i32* } %r_arg, 1 ; [#uses = 9]
  %1 = icmp ugt i64 %r_arg.fca.0.extract, 4       ; [#uses = 1]
  br i1 %1, label %bounds.ok4, label %assertFailed

bounds.ok4:                                       ; preds = %0
  %2 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 1 ; [#uses = 7, type = i32*]
  %3 = load i32, i32* %2, align 4                 ; [#uses = 4]
  %4 = load i32, i32* %r_arg.fca.1.extract, align 4 ; [#uses = 4]
  %5 = icmp slt i32 %3, %4                        ; [#uses = 1]
  br i1 %5, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit198, label %bounds.ok9

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit198: ; preds = %bounds.ok4
  store i32 %3, i32* %r_arg.fca.1.extract, align 4
  store i32 %4, i32* %2, align 4
  br label %bounds.ok9

bounds.ok9:                                       ; preds = %bounds.ok4, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit198
  %6 = phi i32 [ %4, %bounds.ok4 ], [ %3, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit198 ] ; [#uses = 3, type = i32]
  %7 = phi i32 [ %3, %bounds.ok4 ], [ %4, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit198 ] ; [#uses = 4, type = i32]
  %8 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 3 ; [#uses = 6, type = i32*]
  %9 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 2 ; [#uses = 5, type = i32*]
  %10 = load i32, i32* %8, align 4                ; [#uses = 4]
  %11 = load i32, i32* %9, align 4                ; [#uses = 4]
  %12 = icmp slt i32 %10, %11                     ; [#uses = 1]
  br i1 %12, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit206, label %bounds.ok21

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit206: ; preds = %bounds.ok9
  store i32 %10, i32* %9, align 4
  store i32 %11, i32* %8, align 4
  br label %bounds.ok21

bounds.ok21:                                      ; preds = %bounds.ok9, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit206
  %13 = phi i32 [ %11, %bounds.ok9 ], [ %10, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit206 ] ; [#uses = 3, type = i32]
  %14 = phi i32 [ %10, %bounds.ok9 ], [ %11, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit206 ] ; [#uses = 4, type = i32]
  %15 = icmp slt i32 %14, %7                      ; [#uses = 1]
  br i1 %15, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222, label %bounds.ok33

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222: ; preds = %bounds.ok21
  store i32 %13, i32* %r_arg.fca.1.extract, align 4
  store i32 %6, i32* %9, align 4
  store i32 %14, i32* %2, align 4
  store i32 %7, i32* %8, align 4
  br label %bounds.ok33

bounds.ok33:                                      ; preds = %bounds.ok21, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222
  %16 = phi i32 [ %13, %bounds.ok21 ], [ %6, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222 ] ; [#uses = 8, type = i32]
  %17 = phi i32 [ %14, %bounds.ok21 ], [ %7, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222 ] ; [#uses = 9, type = i32]
  %18 = phi i32 [ %6, %bounds.ok21 ], [ %13, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222 ] ; [#uses = 7, type = i32]
  %19 = phi i32 [ %7, %bounds.ok21 ], [ %14, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit222 ] ; [#uses = 8, type = i32]
  %20 = icmp slt i32 %19, %18                     ; [#uses = 1]
  %21 = icmp slt i32 %17, %19                     ; [#uses = 1]
  %or.cond = or i1 %20, %21                       ; [#uses = 1]
  %22 = icmp slt i32 %17, %16                     ; [#uses = 1]
  %or.cond296 = or i1 %or.cond, %22               ; [#uses = 1]
  br i1 %or.cond296, label %assertFailed65, label %bounds.ok68

bounds.ok68:                                      ; preds = %bounds.ok33
  %23 = getelementptr inbounds i32, i32* %r_arg.fca.1.extract, i64 4 ; [#uses = 3, type = i32*]
  %24 = load i32, i32* %23, align 4               ; [#uses = 10]
  %25 = icmp slt i32 %24, %19                     ; [#uses = 1]
  br i1 %25, label %bounds.ok80, label %bounds.ok92

bounds.ok80:                                      ; preds = %bounds.ok68
  store i32 %17, i32* %23, align 4
  store i32 %24, i32* %2, align 4
  store i32 %19, i32* %8, align 4
  %26 = icmp slt i32 %24, %18                     ; [#uses = 1]
  br i1 %26, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254, label %bounds.ok104

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254: ; preds = %bounds.ok80
  store i32 %24, i32* %r_arg.fca.1.extract, align 4
  store i32 %18, i32* %2, align 4
  br label %bounds.ok104

bounds.ok92:                                      ; preds = %bounds.ok68
  %27 = icmp slt i32 %24, %17                     ; [#uses = 1]
  br i1 %27, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262, label %bounds.ok104

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262: ; preds = %bounds.ok92
  store i32 %24, i32* %8, align 4
  store i32 %17, i32* %23, align 4
  br label %bounds.ok104

bounds.ok104:                                     ; preds = %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254, %bounds.ok80, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262, %bounds.ok92
  %28 = phi i32 [ %17, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254 ], [ %17, %bounds.ok80 ], [ %17, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262 ], [ %24, %bounds.ok92 ] ; [#uses = 2, type = i32]
  %29 = phi i32 [ %19, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254 ], [ %19, %bounds.ok80 ], [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262 ], [ %17, %bounds.ok92 ] ; [#uses = 4, type = i32]
  %30 = phi i32 [ %24, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254 ], [ %18, %bounds.ok80 ], [ %18, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262 ], [ %18, %bounds.ok92 ] ; [#uses = 3, type = i32]
  %31 = phi i32 [ %18, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit254 ], [ %24, %bounds.ok80 ], [ %19, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit262 ], [ %19, %bounds.ok92 ] ; [#uses = 4, type = i32]
  %32 = icmp slt i32 %31, %30                     ; [#uses = 1]
  %33 = icmp slt i32 %29, %31                     ; [#uses = 1]
  %or.cond297 = or i1 %32, %33                    ; [#uses = 1]
  %34 = icmp slt i32 %28, %29                     ; [#uses = 1]
  %or.cond298 = or i1 %or.cond297, %34            ; [#uses = 1]
  br i1 %or.cond298, label %assertFailed139, label %bounds.ok142

bounds.ok142:                                     ; preds = %bounds.ok104
  %35 = icmp slt i32 %28, %16                     ; [#uses = 1]
  br i1 %35, label %assertFailed151, label %bounds.ok154

bounds.ok154:                                     ; preds = %bounds.ok142
  %36 = icmp slt i32 %16, %31                     ; [#uses = 1]
  br i1 %36, label %bounds.ok167, label %bounds.ok179

bounds.ok167:                                     ; preds = %bounds.ok154
  store i32 %16, i32* %2, align 4
  store i32 %31, i32* %9, align 4
  %37 = icmp slt i32 %16, %30                     ; [#uses = 1]
  br i1 %37, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230, label %endif163

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230: ; preds = %bounds.ok167
  store i32 %16, i32* %r_arg.fca.1.extract, align 4
  store i32 %30, i32* %2, align 4
  br label %endif163

bounds.ok179:                                     ; preds = %bounds.ok154
  %38 = icmp slt i32 %29, %16                     ; [#uses = 1]
  br i1 %38, label %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, label %endif163

_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit: ; preds = %bounds.ok179
  store i32 %29, i32* %9, align 4
  store i32 %16, i32* %8, align 4
  br label %endif163

endif163:                                         ; preds = %bounds.ok179, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit, %bounds.ok167, %_D3std9algorithm8mutation__T6swapAtTAiZQlFNaNbNiNfKQpmmZv.exit230
  ret void

assertFailed151:                                  ; preds = %bounds.ok142
  tail call void @_d_assert_msg({ i64, i8* } { i64 16, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1842) #5
  unreachable

assertFailed139:                                  ; preds = %bounds.ok104
  tail call void @_d_assert_msg({ i64, i8* } { i64 16, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1838) #5
  unreachable

assertFailed65:                                   ; preds = %bounds.ok33
  tail call void @_d_assert_msg({ i64, i8* } { i64 16, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1821) #5
  unreachable

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 32, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.30, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.13, i32 0, i32 0) }, i32 1807) #5
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8lifetime__T4moveTiZQiFNaNbNiNfKiZi(i32* dereferenceable(4) %source) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  ret i32 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T18trustedMoveEmplaceTiZQxFNaNbNiNeKiKiZv(i32* dereferenceable(4) %target, i32* dereferenceable(4) %source) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  store i32 %1, i32* %target, align 4
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8lifetime__T8moveImplTiZQmFNaNbNiNfKiZi(i32* dereferenceable(4) %source) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  ret i32 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D4core8lifetime__T15trustedMoveImplTiZQuFNaNbNiNeKiZi(i32* dereferenceable(4) %source) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  ret i32 %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8lifetime__T15moveEmplaceImplTiZQuFNaNbNiNfKiKiZv(i32* dereferenceable(4) %source, i32* dereferenceable(4) %target) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  store i32 %1, i32* %target, align 4
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8lifetime__T11moveEmplaceTiZQqFNaNbNiKiKiZv(i32* dereferenceable(4) %target, i32* dereferenceable(4) %source) local_unnamed_addr #0 {
  %1 = load i32, i32* %source, align 4            ; [#uses = 1]
  store i32 %1, i32* %target, align 4
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std5array__T18uninitializedArrayTAkTxiZQBbFNaNbNexiZQt(i32 %_param_0_arg) local_unnamed_addr #0 {
  %1 = sext i32 %_param_0_arg to i64              ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ak6__initZ to %object.TypeInfo*), i64 %1) #8 ; [#uses = 2]
  %.ptr.i = extractvalue { i64, i8* } %2, 1       ; [#uses = 1]
  %.len.i = extractvalue { i64, i8* } %2, 0       ; [#uses = 1]
  %3 = bitcast i8* %.ptr.i to i32*                ; [#uses = 1]
  %.fca.0.insert.i = insertvalue { i64, i32* } undef, i64 %.len.i, 0 ; [#uses = 1]
  %.fca.1.insert8.i = insertvalue { i64, i32* } %.fca.0.insert.i, i32* %3, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std5array__T14arrayAllocImplVbi0TAkTmZQBaFNaNbmZQp(i64 %_param_0_arg) local_unnamed_addr #0 {
  %1 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ak6__initZ to %object.TypeInfo*), i64 %_param_0_arg) #8 ; [#uses = 2]
  %.ptr = extractvalue { i64, i8* } %1, 1         ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %1, 0         ; [#uses = 1]
  %2 = bitcast i8* %.ptr to i32*                  ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i32* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert8 = insertvalue { i64, i32* } %.fca.0.insert, i32* %2, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert8
}

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File__T5writeTlTaZQlMFNflaZv(%std.stdio.File* nonnull %.this_arg, i8 zeroext %_param_1_arg, i64 %_param_0_arg) local_unnamed_addr #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
unrolledstmt:
  %w = alloca %std.stdio.File.LockingTextWriter, align 8 ; [#uses = 7, size/byte = 48]
  %__copytmp202 = 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) #1
  %0 = bitcast %std.stdio.File.LockingTextWriter* %__copytmp202 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 %__copytmp202) #1
          to label %postinvoke3 unwind label %landingPad2

postinvoke3:                                      ; preds = %unrolledstmt
  invoke void @_D3std4conv__T11toTextRangeTlTSQBd5stdio4File17LockingTextWriterZQBzFNflQBqZv(%std.stdio.File.LockingTextWriter* noalias nocapture nonnull align 8 %__copytmp202, i64 %_param_0_arg) #1
          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) #1
          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) #1
  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) #1
  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 = 4]
; Function Attrs: uwtable
declare i32 @_d_eh_personality(i32, i32, i64, i8*, i8*) #4

; [#uses = 4]
; 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 #1

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

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

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

if:                                               ; preds = %0
  %negval.i = sub i64 0, %value_arg               ; [#uses = 1]
  br label %dowhile.i.i

dowhile.i.i:                                      ; preds = %bounds.ok.i.i, %if
  %value.0.i.i = phi i64 [ %negval.i, %if ], [ %value.1.i.i, %bounds.ok.i.i ] ; [#uses = 4, type = i64]
  %i.0.i.i = phi i64 [ 20, %if ], [ %5, %bounds.ok.i.i ] ; [#uses = 3, type = i64]
  %2 = icmp ult i64 %value.0.i.i, 10              ; [#uses = 1]
  br i1 %2, label %endif.i.i, label %else.i.i

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

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

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

bounds.fail.i.i:                                  ; preds = %endif.i.i
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.37, i32 0, i32 0) }, i32 48, i64 -1, i64 20) #5
  unreachable

if2.i:                                            ; preds = %bounds.ok.i.i
  %8 = getelementptr inbounds [20 x i8], [20 x i8]* %buf5, i64 0, i64 %5 ; [#uses = 2, type = i8*]
  %9 = icmp sgt i64 %i.0.i.i, 1                   ; [#uses = 1]
  br i1 %9, label %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit.i, label %assertFailed.i.i

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

_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit.i: ; preds = %if2.i
  %10 = getelementptr inbounds i8, i8* %8, i64 -1 ; [#uses = 2, type = i8*]
  %11 = sub nuw nsw i64 22, %i.0.i.i              ; [#uses = 4]
  %bounds.cmp.not.i = icmp eq i64 %11, 0          ; [#uses = 1]
  br i1 %bounds.cmp.not.i, label %bounds.fail.i, label %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit

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

_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit: ; preds = %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit.i
  store i8 45, i8* %10, align 1
  %12 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %writer, i64 0, i32 1 ; [#uses = 1, type = i32*]
  %13 = load i32, i32* %12, align 8               ; [#uses = 1]
  %14 = icmp slt i32 %13, 1                       ; [#uses = 1]
  br i1 %14, label %if.i.i.i, label %forbody.i.i.i

if.i.i.i:                                         ; preds = %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit
  %15 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %writer, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %16 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %15, align 8 ; [#uses = 1]
  %17 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %16, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %18 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %17, align 8 ; [#uses = 1]
  %19 = call i64 @fwrite(i8* nonnull %10, i64 1, i64 %11, %core.stdc.stdio._IO_FILE* %18) #1 ; [#uses = 1]
  %.not.i.i.i = icmp eq i64 %19, %11              ; [#uses = 1]
  br i1 %.not.i.i.i, label %try.success, label %if1.i.i.i

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

.noexc:                                           ; preds = %if1.i.i.i
  unreachable

forbody.i.i.i:                                    ; preds = %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit, %.noexc6.forbody.i.i.i_crit_edge
  %20 = phi i8 [ %.pre43, %.noexc6.forbody.i.i.i_crit_edge ], [ 45, %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit ] ; [#uses = 1, type = i8]
  %__key201.010.i.i.i = phi i64 [ %21, %.noexc6.forbody.i.i.i_crit_edge ], [ 0, %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd.exit ] ; [#uses = 2, type = i64]
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %writer, i8 zeroext %20) #0
          to label %.noexc6 unwind label %eh.resume.loopexit

.noexc6:                                          ; preds = %forbody.i.i.i
  %21 = add nuw nsw i64 %__key201.010.i.i.i, 1    ; [#uses = 2]
  %exitcond.not.i.i.i = icmp eq i64 %21, %11      ; [#uses = 1]
  br i1 %exitcond.not.i.i.i, label %try.success, label %.noexc6.forbody.i.i.i_crit_edge

.noexc6.forbody.i.i.i_crit_edge:                  ; preds = %.noexc6
  %.phi.trans.insert42 = getelementptr inbounds i8, i8* %8, i64 %__key201.010.i.i.i ; [#uses = 1, type = i8*]
  %.pre43 = load i8, i8* %.phi.trans.insert42, align 1 ; [#uses = 1]
  br label %forbody.i.i.i

dowhile.i:                                        ; preds = %0, %bounds.ok.i8
  %value.0.i = phi i64 [ %value.1.i, %bounds.ok.i8 ], [ %value_arg, %0 ] ; [#uses = 4, type = i64]
  %i.0.i = phi i64 [ %25, %bounds.ok.i8 ], [ 20, %0 ] ; [#uses = 2, type = i64]
  %22 = icmp ult i64 %value.0.i, 10               ; [#uses = 1]
  br i1 %22, label %endif.i, label %else.i

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

endif.i:                                          ; preds = %else.i, %dowhile.i
  %value.1.i = phi i64 [ %24, %else.i ], [ 0, %dowhile.i ] ; [#uses = 2, type = i64]
  %x.0.in.i = phi i64 [ %23, %else.i ], [ %value.0.i, %dowhile.i ] ; [#uses = 1, type = i64]
  %25 = add nsw i64 %i.0.i, -1                    ; [#uses = 4]
  %bounds.cmp.i = icmp ult i64 %25, 20            ; [#uses = 1]
  br i1 %bounds.cmp.i, label %bounds.ok.i8, label %bounds.fail.i9

bounds.ok.i8:                                     ; preds = %endif.i
  %x.0.i = trunc i64 %x.0.in.i to i8              ; [#uses = 1]
  %26 = getelementptr inbounds [20 x i8], [20 x i8]* %buf14, i64 0, i64 %25 ; [#uses = 1, type = i8*]
  %27 = add nuw nsw i8 %x.0.i, 48                 ; [#uses = 2]
  store i8 %27, i8* %26, align 1
  %.not.i = icmp eq i64 %value.1.i, 0             ; [#uses = 1]
  br i1 %.not.i, label %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit, label %dowhile.i

bounds.fail.i9:                                   ; preds = %endif.i
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.37, i32 0, i32 0) }, i32 48, i64 -1, i64 20) #5
  unreachable

_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit: ; preds = %bounds.ok.i8
  %28 = getelementptr inbounds [20 x i8], [20 x i8]* %buf14, i64 0, i64 %25 ; [#uses = 2, type = i8*]
  %29 = sub nuw nsw i64 21, %i.0.i                ; [#uses = 3]
  %30 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %writer, i64 0, i32 1 ; [#uses = 1, type = i32*]
  %31 = load i32, i32* %30, align 8               ; [#uses = 1]
  %32 = icmp slt i32 %31, 1                       ; [#uses = 1]
  br i1 %32, label %if.i.i.i13, label %forbody.i.i.i17

if.i.i.i13:                                       ; preds = %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit
  %33 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %writer, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %34 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %33, align 8 ; [#uses = 1]
  %35 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %34, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %36 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %35, align 8 ; [#uses = 1]
  %37 = call i64 @fwrite(i8* nonnull %28, i64 1, i64 %29, %core.stdc.stdio._IO_FILE* %36) #1 ; [#uses = 1]
  %.not.i.i.i12 = icmp eq i64 %37, %29            ; [#uses = 1]
  br i1 %.not.i.i.i12, label %try.success, label %if1.i.i.i14

if1.i.i.i14:                                      ; preds = %if.i.i.i13
  invoke void @_D3std9exception__T7bailOutHTCQBcQBb14ErrnoExceptionZQBiFNfAyamMAxaZNn({ i64, i8* } zeroinitializer, i64 3263, { i64, i8* } { i64 51, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i32 0, i32 0) }) #7
          to label %.noexc18 unwind label %eh.resume.loopexit.split-lp.loopexit.split-lp

.noexc18:                                         ; preds = %if1.i.i.i14
  unreachable

forbody.i.i.i17:                                  ; preds = %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit, %.noexc19.forbody.i.i.i17_crit_edge
  %38 = phi i8 [ %.pre, %.noexc19.forbody.i.i.i17_crit_edge ], [ %27, %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit ] ; [#uses = 1, type = i8]
  %__key201.010.i.i.i15 = phi i64 [ %39, %.noexc19.forbody.i.i.i17_crit_edge ], [ 0, %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit ] ; [#uses = 1, type = i64]
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %writer, i8 zeroext %38) #0
          to label %.noexc19 unwind label %eh.resume.loopexit.split-lp.loopexit

.noexc19:                                         ; preds = %forbody.i.i.i17
  %39 = add nuw nsw i64 %__key201.010.i.i.i15, 1  ; [#uses = 3]
  %exitcond.not.i.i.i16 = icmp eq i64 %39, %29    ; [#uses = 1]
  br i1 %exitcond.not.i.i.i16, label %try.success, label %.noexc19.forbody.i.i.i17_crit_edge

.noexc19.forbody.i.i.i17_crit_edge:               ; preds = %.noexc19
  %.phi.trans.insert = getelementptr inbounds i8, i8* %28, i64 %39 ; [#uses = 1, type = i8*]
  %.pre = load i8, i8* %.phi.trans.insert, align 1 ; [#uses = 1]
  br label %forbody.i.i.i17

try.success:                                      ; preds = %.noexc19, %.noexc6, %if.i.i.i, %if.i.i.i13
  tail call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #1
  ret void

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

eh.resume.loopexit.split-lp.loopexit:             ; preds = %forbody.i.i.i17
  %lpad.loopexit23 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  br label %eh.resume

eh.resume.loopexit.split-lp.loopexit.split-lp:    ; preds = %if1.i.i.i14, %if1.i.i.i
  %lpad.loopexit.split-lp24 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  br label %eh.resume

eh.resume:                                        ; preds = %eh.resume.loopexit.split-lp.loopexit, %eh.resume.loopexit.split-lp.loopexit.split-lp, %eh.resume.loopexit
  %lpad.phi = phi { i8*, i32 } [ %lpad.loopexit, %eh.resume.loopexit ], [ %lpad.loopexit23, %eh.resume.loopexit.split-lp.loopexit ], [ %lpad.loopexit.split-lp24, %eh.resume.loopexit.split-lp.loopexit.split-lp ] ; [#uses = 1, type = { i8*, i32 }]
  %40 = extractvalue { i8*, i32 } %lpad.phi, 0    ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %writer) #1
  tail call void @_Unwind_Resume(i8* %40)
  unreachable
}

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

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

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

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

; [#uses = 8]
; Function Attrs: uwtable
define weak_odr void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg, i8 zeroext %c_arg) local_unnamed_addr #0 {
  %numCodeUnits.i = alloca i64, align 8           ; [#uses = 3, size/byte = 8]
  %str = alloca { i64, i8* }, align 8             ; [#uses = 3, size/byte = 16]
  %wbuf = alloca [1 x i32], align 4               ; [#uses = 2, size/byte = 4]
  tail call void @_D3std5stdio4File17LockingTextWriter26highSurrogateShouldBeEmptyMFNfZv(%std.stdio.File.LockingTextWriter* nonnull %.this_arg) #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]
  %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) #1 ; [#uses = 1]
  %6 = tail call i32 @fputc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %5) #1 ; [#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) #1 ; [#uses = 1]
  %9 = tail call i32 @fputwc_unlocked(i32 %4, %core.stdc.stdio._IO_FILE* %8) #1 ; [#uses = 0]
  br label %endif

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

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

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

bounds.ok:                                        ; preds = %else6
  %16 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %.this_arg, i64 0, i32 3, i64 %15 ; [#uses = 1, type = i8*]
  store i8 %c_arg, i8* %16, align 1
  %17 = load i64, i64* %14, align 8               ; [#uses = 1]
  %18 = add i64 %17, 1                            ; [#uses = 2]
  store i64 %18, i64* %14, align 8
  %19 = getelementptr [4 x i8], [4 x i8]* %11, i64 0, i64 0 ; [#uses = 2, type = i8*]
  %20 = load i8, i8* %19, align 1                 ; [#uses = 2]
  %21 = icmp sgt i8 %20, -1                       ; [#uses = 1]
  br i1 %21, label %_D3std3utf__T6strideTAaZQlFNaNfQkZk.exit, label %else.i

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

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

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

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

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

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

endfor:                                           ; preds = %forbody.lr.ph, %bounds.ok9
  store i64 0, i64* %14, align 8
  br label %endif

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZ12trustedFPUTCFNbNiNeiPS4core4stdcQDe8_IO_FILEZi(%core.stdc.stdio._IO_FILE* %h_arg, i32 %ch_arg) local_unnamed_addr #0 {
  %1 = tail call i32 @fputc_unlocked(i32 %ch_arg, %core.stdc.stdio._IO_FILE* %h_arg) #1 ; [#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 #9

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

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

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

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

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

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

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

else:                                             ; preds = %bounds.ok
  %3 = tail call i32 @_D3std3utf10strideImplFNaNeamZk(i64 0, i8 zeroext %1) #1 ; [#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.33, i32 0, i32 0) }, i32 403, i64 0, i64 0) #5
  unreachable
}

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

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

if:                                               ; preds = %arrayinit.cond
  %4 = bitcast { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i to i8* ; [#uses = 1]
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %4)
  %5 = bitcast [1 x i32]* %arrayliteral.i to i8*  ; [#uses = 1]
  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %5)
  %.newclass_gc_alloc.i = tail call noalias %object.Object* @_d_allocclass(%object.TypeInfo_Class* nonnull @_D3std3utf12UTFException7__ClassZ) #4 ; [#uses = 4]
  %.newclass_gc.i = bitcast %object.Object* %.newclass_gc_alloc.i to %std.utf.UTFException* ; [#uses = 2]
  %vtbl.i = bitcast %object.Object* %.newclass_gc_alloc.i to [11 x i8*]** ; [#uses = 2]
  store [11 x i8*]* @_D3std3utf12UTFException6__vtblZ, [11 x i8*]** %vtbl.i, align 8
  %6 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* null, i8** %6, align 8
  %7 = getelementptr inbounds %object.Object, %object.Object* %.newclass_gc_alloc.i, i64 1 ; [#uses = 1, type = %object.Object*]
  %8 = bitcast %object.Object* %7 to i8*          ; [#uses = 1]
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(96) %8, i8* nonnull align 8 dereferenceable(96) bitcast ({ i64, i8* }* getelementptr inbounds (%std.utf.UTFException, %std.utf.UTFException* @_D3std3utf12UTFException6__initZ, i64 0, i32 2) to i8*), i64 96, i1 false)
  %msg.sroa.0.0..sroa_idx.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 40, i64* %msg.sroa.0.0..sroa_idx.i, align 8
  %msg.sroa.2.0..sroa_idx1.i = getelementptr inbounds { i64, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite.i, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.36, i64 0, i64 0), i8** %msg.sroa.2.0..sroa_idx1.i, align 8
  %9 = tail call %std.utf.UTFException* @_D3std3utf12UTFException6__ctorMFNaNbNiNfAyaQdmC6object9ThrowableZCQCnQCmQCl(%std.utf.UTFException* nonnull returned %.newclass_gc.i, %object.Throwable* null, i64 2301, { i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.33, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite.i) #1 ; [#uses = 0]
  %10 = load [11 x i8*]*, [11 x i8*]** %vtbl.i, align 8 ; [#uses = 1]
  %"setSequence@vtbl.i" = getelementptr inbounds [11 x i8*], [11 x i8*]* %10, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %11 = bitcast i8** %"setSequence@vtbl.i" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %12 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %11, align 8 ; [#uses = 1]
  %13 = getelementptr inbounds [1 x i32], [1 x i32]* %arrayliteral.i, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 %c_arg, i32* %13, align 4
  %14 = insertvalue { i64, i32* } { i64 1, i32* undef }, i32* %13, 1 ; [#uses = 1]
  %15 = call %std.utf.UTFException* %12(%std.utf.UTFException* nonnull %.newclass_gc.i, { i64, i32* } %14) ; [#uses = 1]
  %16 = bitcast %std.utf.UTFException* %15 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %16) #5
  unreachable

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

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

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

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

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

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

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

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

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

bounds.fail4:                                     ; preds = %if
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 49, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.33, 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) #1 ; [#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.33, 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) #1 ; [#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.33, 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.33, 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 #0 {
  %.frame = alloca %nest.decodeImpl, align 8      ; [#uses = 15, size/byte = 16]
  %str_arg.fca.0.extract = extractvalue { i64, i8* } %str_arg, 0 ; [#uses = 1]
  %str_arg.fca.1.extract = extractvalue { i64, i8* } %str_arg, 1 ; [#uses = 1]
  %pstr = getelementptr inbounds %nest.decodeImpl, %nest.decodeImpl* %.frame, i64 0, i32 0 ; [#uses = 1, type = i8**]
  %length = getelementptr inbounds %nest.decodeImpl, %nest.decodeImpl* %.frame, i64 0, i32 1 ; [#uses = 1, type = i64*]
  %1 = load i64, i64* %index, align 8             ; [#uses = 4]
  %2 = getelementptr inbounds i8, i8* %str_arg.fca.1.extract, i64 %1 ; [#uses = 5, type = i8*]
  store i8* %2, i8** %pstr, align 8
  %3 = sub i64 %str_arg.fca.0.extract, %1         ; [#uses = 4]
  store i64 %3, i64* %length, align 8
  %4 = load i8, i8* %2, align 1                   ; [#uses = 4]
  %5 = zext i8 %4 to i32                          ; [#uses = 3]
  %6 = and i32 %5, 192                            ; [#uses = 1]
  %.not = icmp eq i32 %6, 192                     ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %0
  %7 = bitcast %nest.decodeImpl* %.frame to i8*   ; [#uses = 1]
  %8 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %7) #0 ; [#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* %.frame to i8*  ; [#uses = 1]
  %12 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %11) #0 ; [#uses = 1]
  %13 = bitcast %std.utf.UTFException* %12 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %13) #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* %.frame to i8*  ; [#uses = 1]
  %19 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %18) #0 ; [#uses = 1]
  %20 = bitcast %std.utf.UTFException* %19 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %20) #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* %.frame to i8*  ; [#uses = 1]
  %28 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %27) #0 ; [#uses = 1]
  %29 = bitcast %std.utf.UTFException* %28 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %29) #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* %.frame to i8*  ; [#uses = 1]
  %34 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ11outOfBoundsMFNaNbZCQFgQFf12UTFException(i8* nonnull %33) #0 ; [#uses = 1]
  %35 = bitcast %std.utf.UTFException* %34 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %35) #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* %.frame to i8*  ; [#uses = 1]
  %41 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %40) #0 ; [#uses = 1]
  %42 = bitcast %std.utf.UTFException* %41 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %42) #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* %.frame to i8*  ; [#uses = 1]
  %51 = call %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ10invalidUTFMFNaNbZCQFfQFe12UTFException(i8* nonnull %50) #0 ; [#uses = 1]
  %52 = bitcast %std.utf.UTFException* %51 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %52) #5
  unreachable

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

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

endif41:                                          ; preds = %endif38
  ret i32 %72

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T3putTSQBf5stdio4File17LockingTextWriterTAaZQBrFNfKQBtQnZv({ i64, i8* } %e_arg, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  %e_arg.fca.0.extract = extractvalue { i64, i8* } %e_arg, 0 ; [#uses = 4]
  %e_arg.fca.1.extract = extractvalue { i64, i8* } %e_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %r, 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.i.i, label %forcond.preheader.i.i

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

if.i.i:                                           ; preds = %0
  %4 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %r, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %5 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %4, align 8 ; [#uses = 1]
  %6 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %5, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %7 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %6, align 8 ; [#uses = 1]
  %8 = tail call i64 @fwrite(i8* %e_arg.fca.1.extract, i64 1, i64 %e_arg.fca.0.extract, %core.stdc.stdio._IO_FILE* %7) #1 ; [#uses = 1]
  %.not.i.i = icmp eq i64 %8, %e_arg.fca.0.extract ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv.exit, label %if1.i.i

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

forbody.i.i:                                      ; preds = %forcond.preheader.i.i, %forbody.i.i
  %__key201.010.i.i = phi i64 [ %11, %forbody.i.i ], [ 0, %forcond.preheader.i.i ] ; [#uses = 2, type = i64]
  %9 = getelementptr inbounds i8, i8* %e_arg.fca.1.extract, i64 %__key201.010.i.i ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %r, i8 zeroext %10) #0
  %11 = add nuw i64 %__key201.010.i.i, 1          ; [#uses = 2]
  %exitcond.not.i.i = icmp eq i64 %11, %e_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond.not.i.i, label %_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv.exit, label %forbody.i.i

_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv.exit: ; preds = %forbody.i.i, %forcond.preheader.i.i, %if.i.i
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZQd({ i64, i8* } %buf_arg, i64 %value_arg) local_unnamed_addr #0 {
endif:
  %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]
  %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]
  br label %dowhile.i

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

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

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

bounds.ok.i:                                      ; preds = %endif.i
  %x.0.i = trunc i64 %x.0.in.i 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.i, 48                  ; [#uses = 1]
  store i8 %6, i8* %5, align 1
  %.not.i = icmp eq i64 %value.1.i, 0             ; [#uses = 1]
  br i1 %.not.i, label %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit, label %dowhile.i

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

_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit: ; preds = %bounds.ok.i
  %7 = getelementptr inbounds i8, i8* %buf_arg.fca.1.extract, i64 %4 ; [#uses = 2, type = i8*]
  %8 = sub i64 %buf_arg.fca.0.extract, %4         ; [#uses = 2]
  br i1 %0, label %if2, label %endif3

if2:                                              ; preds = %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit
  %9 = icmp sgt i64 %4, 0                         ; [#uses = 1]
  br i1 %9, label %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit, label %assertFailed.i

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

_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit: ; preds = %if2
  %10 = getelementptr inbounds i8, i8* %7, i64 -1 ; [#uses = 2, type = i8*]
  %11 = add i64 %8, 1                             ; [#uses = 2]
  %bounds.cmp.not = icmp eq i64 %11, 0            ; [#uses = 1]
  br i1 %bounds.cmp.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh.exit
  store i8 45, i8* %10, align 1
  br label %endif3

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

endif3:                                           ; preds = %bounds.ok, %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit
  %r.sroa.6.0 = phi i8* [ %10, %bounds.ok ], [ %7, %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit ] ; [#uses = 1, type = i8*]
  %r.sroa.0.0 = phi i64 [ %11, %bounds.ok ], [ %8, %_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd.exit ] ; [#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 = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T20unsignedToTempStringVki10ZQBcFNaNbNiNfmMNkAaZQd({ i64, i8* } %buf_arg, i64 %value_arg) local_unnamed_addr #0 {
  %buf_arg.fca.0.extract = extractvalue { i64, i8* } %buf_arg, 0 ; [#uses = 4]
  %buf_arg.fca.1.extract = extractvalue { i64, i8* } %buf_arg, 1 ; [#uses = 2]
  br label %dowhile

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

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

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

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

bounds.fail:                                      ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 62, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.37, 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 = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D4core8internal6string__T18signedToTempStringVki10ZQBaFNaNbNiNflMNkAaZ12trustedSliceMFNaNbNiNeNkQBdZQBh(i8* nonnull %.nest_arg, { i64, i8* } %r_arg) local_unnamed_addr #0 {
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 2]
  %1 = getelementptr inbounds i8, i8* %.nest_arg, i64 8 ; [#uses = 1, type = i8*]
  %2 = bitcast i8* %1 to i8**                     ; [#uses = 1]
  %.ptr1 = load i8*, i8** %2, align 8             ; [#uses = 1]
  %3 = icmp ugt i8* %r_arg.fca.1.extract, %.ptr1  ; [#uses = 1]
  br i1 %3, label %assertPassed, label %assertFailed

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T5doPutTSQBh5stdio4File17LockingTextWriterTAaZQBtFNfKQBtKQoZv({ i64, i8* }* dereferenceable(16) %e, %std.stdio.File.LockingTextWriter* dereferenceable(48) %r) local_unnamed_addr #0 {
  %.elt = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.unpack = load i64, i64* %.elt, align 8        ; [#uses = 4]
  %.elt1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %e, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 2]
  %1 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %r, 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.i, label %forcond.preheader.i

forcond.preheader.i:                              ; preds = %0
  %.not11.i = icmp eq i64 %.unpack, 0             ; [#uses = 1]
  br i1 %.not11.i, label %_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv.exit, label %forbody.i

if.i:                                             ; preds = %0
  %4 = getelementptr inbounds %std.stdio.File.LockingTextWriter, %std.stdio.File.LockingTextWriter* %r, i64 0, i32 0, i32 0 ; [#uses = 1, type = %std.stdio.File.Impl**]
  %5 = load %std.stdio.File.Impl*, %std.stdio.File.Impl** %4, align 8 ; [#uses = 1]
  %6 = getelementptr inbounds %std.stdio.File.Impl, %std.stdio.File.Impl* %5, i64 0, i32 0 ; [#uses = 1, type = %core.stdc.stdio._IO_FILE**]
  %7 = load %core.stdc.stdio._IO_FILE*, %core.stdc.stdio._IO_FILE** %6, align 8 ; [#uses = 1]
  %8 = tail call i64 @fwrite(i8* %.unpack2, i64 1, i64 %.unpack, %core.stdc.stdio._IO_FILE* %7) #1 ; [#uses = 1]
  %.not.i = icmp eq i64 %8, %.unpack              ; [#uses = 1]
  br i1 %.not.i, label %_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv.exit, label %if1.i

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

forbody.i:                                        ; preds = %forcond.preheader.i, %forbody.i
  %__key201.010.i = phi i64 [ %11, %forbody.i ], [ 0, %forcond.preheader.i ] ; [#uses = 2, type = i64]
  %9 = getelementptr inbounds i8, i8* %.unpack2, i64 %__key201.010.i ; [#uses = 1, type = i8*]
  %10 = load i8, i8* %9, align 1                  ; [#uses = 1]
  tail call void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %r, i8 zeroext %10) #0
  %11 = add nuw i64 %__key201.010.i, 1            ; [#uses = 2]
  %exitcond.not.i = icmp eq i64 %11, %.unpack     ; [#uses = 1]
  br i1 %exitcond.not.i, label %_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv.exit, label %forbody.i

_D3std5stdio4File17LockingTextWriter__T3putTAaZQiMFNfMQkZv.exit: ; preds = %forbody.i, %forcond.preheader.i, %if.i
  ret void
}

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std9algorithm8mutation__T8moveImplTAiZQnFNaNbNiNfMNkKQsZQv({ i64, i32* }* dereferenceable(16) %source) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i.i = load i64, i64* %1, align 8        ; [#uses = 2]
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2.i.i.i = load i8*, i8** %3, align 8       ; [#uses = 7]
  %4 = shl i64 %.len.i.i.i, 2                     ; [#uses = 1]
  %5 = bitcast { i64, i32* }* %source to i8*      ; [#uses = 4]
  %6 = getelementptr inbounds i8, i8* %.ptr2.i.i.i, i64 %4 ; [#uses = 3, type = i8*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 3]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i.i.i.i = icmp ule i8* %.ptr2.i.i.i, %5   ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i.i.i.i = and i1 %.not.i.i.i.i, %10  ; [#uses = 1]
  %11 = ptrtoint i8* %.ptr2.i.i.i to i64          ; [#uses = 1]
  br i1 %andandval.i.i.i.i, label %if.i.i.i.i, label %endif.i.i.i.i

if.i.i.i.i:                                       ; preds = %0
  %12 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i to i64 ; [#uses = 1]
  %13 = ptrtoint { i64, i32* }* %source to i64    ; [#uses = 1]
  %14 = sub i64 %12, %13                          ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i

endif.i.i.i.i:                                    ; preds = %0
  %.not28.i.i.i.i = icmp uge i8* %.ptr2.i.i.i, %5 ; [#uses = 1]
  %17 = icmp ult i8* %.ptr2.i.i.i, %8             ; [#uses = 1]
  %andandval17.i.i.i.i = and i1 %.not28.i.i.i.i, %17 ; [#uses = 1]
  br i1 %andandval17.i.i.i.i, label %if18.i.i.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i

if18.i.i.i.i:                                     ; preds = %endif.i.i.i.i
  %18 = ptrtoint i8* %b_arg.a_arg.i.i.i.i.i to i64 ; [#uses = 1]
  %19 = sub i64 %18, %11                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2.i.i.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i: ; preds = %if18.i.i.i.i, %endif.i.i.i.i, %if.i.i.i.i
  %22 = phi { i64, i8* } [ %16, %if.i.i.i.i ], [ %21, %if18.i.i.i.i ], [ zeroinitializer, %endif.i.i.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i.i.i = extractvalue { i64, i8* } %22, 0 ; [#uses = 1]
  %.not.i.i = icmp eq i64 %.len1.i.i.i, 0         ; [#uses = 1]
  br i1 %.not.i.i, label %_D3std9algorithm8mutation__T15trustedMoveImplTAiZQvFNaNbNiNeMNkKQsZQv.exit, label %assertFailed.i.i

assertFailed.i.i:                                 ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.38, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 1429) #5
  unreachable

_D3std9algorithm8mutation__T15trustedMoveImplTAiZQvFNaNbNiNeMNkKQsZQv.exit: ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i.i
  %.fca.0.insert.i = insertvalue { i64, i32* } undef, i64 %.len.i.i.i, 0 ; [#uses = 1]
  %23 = bitcast i8* %.ptr2.i.i.i to i32*          ; [#uses = 1]
  %.fca.1.insert6.i = insertvalue { i64, i32* } %.fca.0.insert.i, i32* %23, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert6.i
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i32* } @_D3std9algorithm8mutation__T15trustedMoveImplTAiZQvFNaNbNiNeMNkKQsZQv({ i64, i32* }* dereferenceable(16) %source) local_unnamed_addr #0 {
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i.i = load i64, i64* %1, align 8          ; [#uses = 2]
  %2 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %3 = bitcast i32** %2 to i8**                   ; [#uses = 1]
  %.ptr2.i.i = load i8*, i8** %3, align 8         ; [#uses = 7]
  %4 = shl i64 %.len.i.i, 2                       ; [#uses = 1]
  %5 = bitcast { i64, i32* }* %source to i8*      ; [#uses = 4]
  %6 = getelementptr inbounds i8, i8* %.ptr2.i.i, i64 %4 ; [#uses = 3, type = i8*]
  %7 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %8 = bitcast { i64, i32* }* %7 to i8*           ; [#uses = 3]
  %9 = icmp ugt i8* %6, %8                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i.i = select i1 %9, i8* %8, i8* %6 ; [#uses = 2]
  %.not.i.i.i = icmp ule i8* %.ptr2.i.i, %5       ; [#uses = 1]
  %10 = icmp ugt i8* %6, %5                       ; [#uses = 1]
  %andandval.i.i.i = and i1 %.not.i.i.i, %10      ; [#uses = 1]
  %11 = ptrtoint i8* %.ptr2.i.i to i64            ; [#uses = 1]
  br i1 %andandval.i.i.i, label %if.i.i.i, label %endif.i.i.i

if.i.i.i:                                         ; preds = %0
  %12 = ptrtoint i8* %b_arg.a_arg.i.i.i.i to i64  ; [#uses = 1]
  %13 = ptrtoint { i64, i32* }* %source to i64    ; [#uses = 1]
  %14 = sub i64 %12, %13                          ; [#uses = 1]
  %15 = insertvalue { i64, i8* } undef, i64 %14, 0 ; [#uses = 1]
  %16 = insertvalue { i64, i8* } %15, i8* %5, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i

endif.i.i.i:                                      ; preds = %0
  %.not28.i.i.i = icmp uge i8* %.ptr2.i.i, %5     ; [#uses = 1]
  %17 = icmp ult i8* %.ptr2.i.i, %8               ; [#uses = 1]
  %andandval17.i.i.i = and i1 %.not28.i.i.i, %17  ; [#uses = 1]
  br i1 %andandval17.i.i.i, label %if18.i.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i

if18.i.i.i:                                       ; preds = %endif.i.i.i
  %18 = ptrtoint i8* %b_arg.a_arg.i.i.i.i to i64  ; [#uses = 1]
  %19 = sub i64 %18, %11                          ; [#uses = 1]
  %20 = insertvalue { i64, i8* } undef, i64 %19, 0 ; [#uses = 1]
  %21 = insertvalue { i64, i8* } %20, i8* %.ptr2.i.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i: ; preds = %if18.i.i.i, %endif.i.i.i, %if.i.i.i
  %22 = phi { i64, i8* } [ %16, %if.i.i.i ], [ %21, %if18.i.i.i ], [ zeroinitializer, %endif.i.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i.i = extractvalue { i64, i8* } %22, 0   ; [#uses = 1]
  %.not.i = icmp eq i64 %.len1.i.i, 0             ; [#uses = 1]
  br i1 %.not.i, label %_D3std9algorithm8mutation__T15moveEmplaceImplTAiZQvFNaNbNiNfMKQqMNkKQwZv.exit, label %assertFailed.i

assertFailed.i:                                   ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.38, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 1429) #5
  unreachable

_D3std9algorithm8mutation__T15moveEmplaceImplTAiZQvFNaNbNiNfMKQqMNkKQwZv.exit: ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit.i
  %.fca.0.insert = insertvalue { i64, i32* } undef, i64 %.len.i.i, 0 ; [#uses = 1]
  %23 = bitcast i8* %.ptr2.i.i to i32*            ; [#uses = 1]
  %.fca.1.insert6 = insertvalue { i64, i32* } %.fca.0.insert, i32* %23, 1 ; [#uses = 1]
  ret { i64, i32* } %.fca.1.insert6
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T15moveEmplaceImplTAiZQvFNaNbNiNfMKQqMNkKQwZv({ i64, i32* }* dereferenceable(16) %source, { i64, i32* }* dereferenceable(16) %target) local_unnamed_addr #0 {
andandend:
  %0 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len.i = load i64, i64* %0, align 8            ; [#uses = 2]
  %1 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %2 = bitcast i32** %1 to i8**                   ; [#uses = 1]
  %.ptr2.i = load i8*, i8** %2, align 8           ; [#uses = 6]
  %3 = shl i64 %.len.i, 2                         ; [#uses = 1]
  %4 = bitcast { i64, i32* }* %source to i8*      ; [#uses = 4]
  %5 = getelementptr inbounds i8, i8* %.ptr2.i, i64 %3 ; [#uses = 3, type = i8*]
  %6 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %source, i64 1 ; [#uses = 1, type = { i64, i32* }*]
  %7 = bitcast { i64, i32* }* %6 to i8*           ; [#uses = 3]
  %8 = icmp ugt i8* %5, %7                        ; [#uses = 1]
  %b_arg.a_arg.i.i.i = select i1 %8, i8* %7, i8* %5 ; [#uses = 2]
  %.not.i.i = icmp ule i8* %.ptr2.i, %4           ; [#uses = 1]
  %9 = icmp ugt i8* %5, %4                        ; [#uses = 1]
  %andandval.i.i = and i1 %.not.i.i, %9           ; [#uses = 1]
  %10 = ptrtoint i8* %.ptr2.i to i64              ; [#uses = 2]
  br i1 %andandval.i.i, label %if.i.i, label %endif.i.i

if.i.i:                                           ; preds = %andandend
  %11 = ptrtoint i8* %b_arg.a_arg.i.i.i to i64    ; [#uses = 1]
  %12 = ptrtoint { i64, i32* }* %source to i64    ; [#uses = 1]
  %13 = sub i64 %11, %12                          ; [#uses = 1]
  %14 = insertvalue { i64, i8* } undef, i64 %13, 0 ; [#uses = 1]
  %15 = insertvalue { i64, i8* } %14, i8* %4, 1   ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

endif.i.i:                                        ; preds = %andandend
  %.not28.i.i = icmp uge i8* %.ptr2.i, %4         ; [#uses = 1]
  %16 = icmp ult i8* %.ptr2.i, %7                 ; [#uses = 1]
  %andandval17.i.i = and i1 %.not28.i.i, %16      ; [#uses = 1]
  br i1 %andandval17.i.i, label %if18.i.i, label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

if18.i.i:                                         ; preds = %endif.i.i
  %17 = ptrtoint i8* %b_arg.a_arg.i.i.i to i64    ; [#uses = 1]
  %18 = sub i64 %17, %10                          ; [#uses = 1]
  %19 = insertvalue { i64, i8* } undef, i64 %18, 0 ; [#uses = 1]
  %20 = insertvalue { i64, i8* } %19, i8* %.ptr2.i, 1 ; [#uses = 1]
  br label %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit

_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit: ; preds = %if.i.i, %endif.i.i, %if18.i.i
  %21 = phi { i64, i8* } [ %15, %if.i.i ], [ %20, %if18.i.i ], [ zeroinitializer, %endif.i.i ] ; [#uses = 1, type = { i64, i8* }]
  %.len1.i = extractvalue { i64, i8* } %21, 0     ; [#uses = 1]
  %.not = icmp eq i64 %.len1.i, 0                 ; [#uses = 1]
  br i1 %.not, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit
  %22 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %target, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len.i, i64* %22, align 8
  %23 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %target, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %24 = bitcast i32** %23 to i64*                 ; [#uses = 1]
  store i64 %10, i64* %24, align 8
  ret void

assertFailed:                                     ; preds = %_D3std9exception__T11doesPointToTAiTQdTvZQwFNaNbNiNeKxAiKxQeZb.exit
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.38, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.18, i32 0, i32 0) }, i32 1429) #5
  unreachable
}

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

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

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

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

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

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

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

!llvm.ldc.typeinfo._D6source11InputReader7__ClassZ = !{!0}
!llvm.ldc.classinfo._D6source11InputReader7__ClassZ = !{!1}
!llvm.ldc.typeinfo._D6Object7__ClassZ = !{!2}
!llvm.ldc.classinfo._D6Object7__ClassZ = !{!3}
!llvm.ldc.typeinfo._D12TypeInfo_AAi6__initZ = !{!4}
!llvm.ldc.typeinfo._D11TypeInfo_Ai6__initZ = !{!5}
!llvm.ldc.typeinfo._D9Exception7__ClassZ = !{!6}
!llvm.ldc.classinfo._D9Exception7__ClassZ = !{!7}
!llvm.ldc.typeinfo._D12TypeInfo_Axa6__initZ = !{!8}
!llvm.ldc.typeinfo._D12TypeInfo_Aya6__initZ = !{!8}
!llvm.ldc.typeinfo._D3std9exception14ErrnoException7__ClassZ = !{!9}
!llvm.ldc.classinfo._D3std9exception14ErrnoException7__ClassZ = !{!10}
!llvm.ldc.typeinfo._D11TypeInfo_Ah6__initZ = !{!8}
!llvm.ldc.typeinfo._D12TypeInfo_xAi6__initZ = !{!5}
!llvm.ldc.typeinfo._D12TypeInfo_Axi6__initZ = !{!5}
!llvm.ldc.typeinfo._D11TypeInfo_xi6__initZ = !{!11}
!llvm.ldc.typeinfo._D10TypeInfo_i6__initZ = !{!11}
!llvm.ldc.typeinfo._D11TypeInfo_Ak6__initZ = !{!5}
!llvm.ldc.typeinfo._D3std3utf12UTFException7__ClassZ = !{!12}
!llvm.ldc.classinfo._D3std3utf12UTFException7__ClassZ = !{!13}
!llvm.ident = !{!14}

!0 = !{%source.InputReader* undef}
!1 = !{%source.InputReader undef, i1 false}
!2 = !{%object.Object* undef}
!3 = !{%object.Object undef, i1 false}
!4 = !{{ i64, { i64, i32* }* } undef}
!5 = !{{ i64, i32* } undef}
!6 = !{%object.Exception* undef}
!7 = !{%object.Exception undef, i1 false}
!8 = !{{ i64, i8* } undef}
!9 = !{%std.exception.ErrnoException* undef}
!10 = !{%std.exception.ErrnoException undef, i1 false}
!11 = !{i32 undef}
!12 = !{%std.utf.UTFException* undef}
!13 = !{%std.utf.UTFException undef, i1 false}
!14 = !{!"ldc version 1.28.0"}
!15 = !{i8 0, i8 2}
