import std;
import core.bitop;

ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "x", long, "g");
alias PQueue(T, alias less = "a>b") = BinaryHeap!(Array!T, less);

void main()
{
    auto s = sread();
    auto t = sread();
    writeln(sort!"a<b"(cast(ubyte[]) s).array() < sort!"a>b"(cast(ubyte[]) t).array() ? "Yes" : "No");
}

void scan(TList...)(ref TList Args)
{
    auto line = readln.split();
    foreach (i, T; TList)
    {
        T val = line[i].to!(T);
        Args[i] = val;
    }
}

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

%0 = type opaque
%1 = type opaque
%2 = type opaque
%3 = type opaque
%4 = type opaque
%5 = type opaque
%6 = type { i32, i32, i64, [6 x %object.ModuleInfo*], [7 x i8] }
%object.TypeInfo_Class = type { [20 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, { i64, i8** }, { i64, %object.Interface* }, %object.TypeInfo_Class*, i8*, void (%object.Object*)*, i32, [4 x i8], i8*, { i64, %object.OffsetTypeInfo* }, void (%object.Object*)*, i8* }
%object.Interface = type { %object.TypeInfo_Class*, { i64, i8** }, i64 }
%object.OffsetTypeInfo = type { i64, %object.TypeInfo* }
%object.TypeInfo = type { [19 x i8*]*, i8* }
%object.Object = type { [5 x i8*]*, i8* }
%object.Exception = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.Throwable.TraceInfo = type { [4 x i8*]* }
%object.Throwable = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32 }>
%object.TypeInfo_Const = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%std.exception.ErrnoException = type <{ [10 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, i32 }>
%std.utf.UTFException = type <{ [11 x i8*]*, i8*, { i64, i8* }, { i64, i8* }, i64, %object.Throwable.TraceInfo*, %object.Throwable*, i32, [4 x i8], i64, [4 x i32], i64 }>
%object.ModuleInfo = type { i32, i32 }
%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" = type { { i64, i8* } }
%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" = type { { i64, i8* } }
%std.stdio.File = type { %std.stdio.File.Impl*, { i64, i8* } }
%std.stdio.File.Impl = type { %core.stdc.stdio._IO_FILE*, i32, i8, [3 x i8], i32, [4 x i8] }
%core.stdc.stdio._IO_FILE = type { i32, [4 x i8], i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %core.stdc.stdio._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], [4 x i8], i8*, i64, i8*, i8*, %core.stdc.stdio._IO_FILE*, i8*, i64, i32, [20 x i8] }
%std.stdio.File.LockingTextWriter = type { %std.stdio.File, i32, i16, [4 x i8], [6 x i8], i64 }
%"std.typecons.Tuple!(long, long).Tuple" = type { i64, i64 }
%"std.typecons.Tuple!(long, \22x\22, long, \22g\22).Tuple" = type { i64, i64 }
%"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S" = type { i8 }
%nest.decodeImpl = type { i8*, i64 }

@_D6source3MAXm = thread_local local_unnamed_addr global i64 100100, align 8 ; [#uses = 0]
@_D6source3MODm = thread_local local_unnamed_addr global i64 1000000007, align 8 ; [#uses = 0]
@_D6source3INFm = thread_local local_unnamed_addr global i64 1000000000000, align 8 ; [#uses = 0]
@.str = private unnamed_addr constant [4 x i8] c"Yes\00" ; [#uses = 1]
@.str.1 = private unnamed_addr constant [3 x i8] c"No\00" ; [#uses = 1]
@.str.2 = private unnamed_addr constant [39 x i8] c"Attempt to read from an unopened file.\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]
@_D9Exception7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 1]
@_D9Exception6__vtblZ = external constant [10 x i8*] ; [#uses = 1]
@_D9Exception6__initZ = external local_unnamed_addr constant %object.Exception, align 8 ; [#uses = 1]
@.str.4 = private unnamed_addr constant [19 x i8] c"Enforcement failed\00" ; [#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]
@.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 [56 x i8] c"Attempting to fetch the back of an empty array of ubyte\00" ; [#uses = 1]
@.str.10 = private unnamed_addr constant [37 x i8] c"Failed to sort range of type ubyte[]\00" ; [#uses = 1]
@.str.11 = 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.12 = 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.13 = 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_xAh6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_Axh6__initZ to %object.TypeInfo*) } ; [#uses = 3]
@_D14TypeInfo_Const6__vtblZ = external constant [19 x i8*] ; [#uses = 2]
@_D12TypeInfo_Axh6__initZ = linkonce_odr global %object.TypeInfo_Array { [19 x i8*]* @_D14TypeInfo_Array6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Const* @_D11TypeInfo_xh6__initZ to %object.TypeInfo*) } ; [#uses = 1]
@_D14TypeInfo_Array6__vtblZ = external constant [19 x i8*] ; [#uses = 1]
@_D11TypeInfo_xh6__initZ = linkonce_odr global %object.TypeInfo_Const { [19 x i8*]* @_D14TypeInfo_Const6__vtblZ, i8* null, %object.TypeInfo* @_D10TypeInfo_h6__initZ } ; [#uses = 1]
@_D10TypeInfo_h6__initZ = external global %object.TypeInfo ; [#uses = 1]
@.str.14 = private unnamed_addr constant [35 x i8] c"sort: invalid comparison function.\00" ; [#uses = 1]
@.str.15 = private unnamed_addr constant [16 x i8] c"r is not a heap\00" ; [#uses = 1]
@.str.16 = 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.17 = private unnamed_addr constant [49 x i8] c"r.length must be greater equal to Indexes.length\00" ; [#uses = 1]
@.str.18 = private unnamed_addr constant [8 x i8] c"a != b \00" ; [#uses = 1]
@.str.19 = private unnamed_addr constant [17 x i8] c"a != c && b != c\00" ; [#uses = 1]
@.str.20 = private unnamed_addr constant [23 x i8] c"less than check failed\00" ; [#uses = 1]
@.str.21 = private unnamed_addr constant [34 x i8] c"a != d && b != d && c != d failed\00" ; [#uses = 1]
@.str.22 = private unnamed_addr constant [44 x i8] c"a != e && b != e && c != e && d != e failed\00" ; [#uses = 1]
@.str.23 = private unnamed_addr constant [28 x i8] c"Swap: lhs internal pointer.\00" ; [#uses = 1]
@.str.24 = private unnamed_addr constant [28 x i8] c"Swap: rhs internal pointer.\00" ; [#uses = 1]
@.str.25 = private unnamed_addr constant [25 x i8] c"Swap: lhs points to rhs.\00" ; [#uses = 1]
@.str.26 = private unnamed_addr constant [25 x i8] c"Swap: rhs points to lhs.\00" ; [#uses = 1]
@.str.28 = private unnamed_addr constant [33 x i8] c"r must have more than 4 elements\00" ; [#uses = 1]
@.str.29 = private unnamed_addr constant [17 x i8] c"unexpected order\00" ; [#uses = 1]
@.str.31 = private unnamed_addr constant [52 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/array.d\00" ; [#uses = 1]
@_D11TypeInfo_Ah6__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.32 = private unnamed_addr constant [50 x i8] c"/usr/lib/ldc/x86_64-linux-gnu/include/d/std/utf.d\00" ; [#uses = 1]
@.str.33 = private unnamed_addr constant [23 x i8] c"Invalid UTF-8 sequence\00" ; [#uses = 1]
@.str.34 = private unnamed_addr constant [45 x i8] c"Attempted to decode past the end of a string\00" ; [#uses = 1]
@_D3std3utf12UTFException7__ClassZ = external global %object.TypeInfo_Class ; [#uses = 2]
@_D3std3utf12UTFException6__vtblZ = external constant [11 x i8*] ; [#uses = 2]
@_D3std3utf12UTFException6__initZ = external local_unnamed_addr constant %std.utf.UTFException, align 8 ; [#uses = 1]
@.str.35 = private unnamed_addr constant [41 x i8] c"Encoding an invalid code point in UTF-32\00" ; [#uses = 1]
@.str.36 = 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]
@_D3std12__ModuleInfoZ = external global %0       ; [#uses = 1]
@_D3std9exception12__ModuleInfoZ = external global %1 ; [#uses = 1]
@_D3std9algorithm8mutation12__ModuleInfoZ = external global %2 ; [#uses = 1]
@_D3std6traits12__ModuleInfoZ = external global %3 ; [#uses = 1]
@_D3std8typecons12__ModuleInfoZ = external global %4 ; [#uses = 1]
@_D3std5array12__ModuleInfoZ = external global %5 ; [#uses = 1]
@_D6source12__ModuleInfoZ = global %6 { i32 -2147482624, i32 0, i64 6, [6 x %object.ModuleInfo*] [%object.ModuleInfo* bitcast (%0* @_D3std12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%1* @_D3std9exception12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%2* @_D3std9algorithm8mutation12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%3* @_D3std6traits12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%4* @_D3std8typecons12__ModuleInfoZ to %object.ModuleInfo*), %object.ModuleInfo* bitcast (%5* @_D3std5array12__ModuleInfoZ to %object.ModuleInfo*)], [7 x i8] c"source\00" } ; [#uses = 1]
@_D6source11__moduleRefZ = linkonce_odr hidden global %object.ModuleInfo* bitcast (%6* @_D6source12__ModuleInfoZ to %object.ModuleInfo*), section "__minfo" ; [#uses = 1]
@__start___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@__stop___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@ldc.dso_slot = linkonce_odr hidden global i8* null ; [#uses = 1]
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.global_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.used = appending global [1 x i8*] [i8* bitcast (%object.ModuleInfo** @_D6source11__moduleRefZ to i8*)], section "llvm.metadata" ; [#uses = 0]

; [#uses = 1]
; Function Attrs: uwtable
define i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #0 {
condend:
  %0 = tail call { i64, i8* } @_D6source10__lambda14FZAya() #1 ; [#uses = 1]
  %1 = tail call { i64, i8* } @_D6source10__lambda14FZAya() #1 ; [#uses = 1]
  %2 = tail call %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std9algorithm7sorting__T4sortVAyaa3_613c62VEQBtQBs8mutation12SwapStrategyi0TAhZQCdFNaNbNiNfQpZSQDs5range__T11SortedRangeTQBtVQDra3_613c62VEQFkQBs18SortedRangeOptionsi0ZQCj({ i64, i8* } %0) #2 ; [#uses = 1]
  %3 = tail call { i64, i8* } @_D3std5array__TQjTSQr5range__T11SortedRangeTAhVAyaa3_613c62VEQChQBr18SortedRangeOptionsi0ZQCiZQDkFNaNbNfQDiZQCm(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %2) #2 ; [#uses = 1]
  %4 = tail call %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std9algorithm7sorting__T4sortVAyaa3_613e62VEQBtQBs8mutation12SwapStrategyi0TAhZQCdFNaNbNiNfQpZSQDs5range__T11SortedRangeTQBtVQDra3_613e62VEQFkQBs18SortedRangeOptionsi0ZQCj({ i64, i8* } %1) #2 ; [#uses = 1]
  %5 = tail call { i64, i8* } @_D3std5array__TQjTSQr5range__T11SortedRangeTAhVAyaa3_613e62VEQChQBr18SortedRangeOptionsi0ZQCiZQDkFNaNbNfQDiZQCm(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %4) #2 ; [#uses = 1]
  %6 = tail call i32 @_D4core8internal5array10comparison__T5__cmpThZQjFNaNbNiNeMxAhMxQeZi({ i64, i8* } %5, { i64, i8* } %3) #2 ; [#uses = 1]
  %7 = icmp slt i32 %6, 0                         ; [#uses = 2]
  %. = select i1 %7, i64 3, i64 2                 ; [#uses = 1]
  %.21 = select i1 %7, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0) ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %., 0 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.21, 1 ; [#uses = 1]
  tail call void @_D3std5stdio__T7writelnTAyaZQnFNfQjZv({ i64, i8* } %.fca.1.insert) #2
  ret i32 0
}

; [#uses = 2]
; Function Attrs: uwtable
define linkonce_odr { i64, i8* } @_D6source10__lambda14FZAya() local_unnamed_addr #1 {
  %1 = tail call { i64, i8* } @_D3std5stdio__T6readlnTAyaZQmFwZQj(i32 10) #2 ; [#uses = 1]
  %2 = tail call { i64, i8* } @_D3std6string__T5chompTAyaZQlFNaNbNiNfQpZQs({ i64, i8* } %1) #2 ; [#uses = 1]
  ret { i64, i8* } %2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

toElem.success:                                   ; preds = %0
  call void @_D3std5stdio4File6__dtorMFNfZv(%std.stdio.File* nonnull %__tmpfordtor409) #2
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTAyaZQjMFNfMQlZv(%std.stdio.File.LockingTextWriter* nonnull %w, { i64, i8* } %_param_0_arg) #2
          to label %postinvoke2 unwind label %finally

postinvoke2:                                      ; preds = %toElem.success
  invoke void @_D3std5stdio4File17LockingTextWriter__T3putTaZQhMFNfaZv(%std.stdio.File.LockingTextWriter* nonnull %w, i8 zeroext 10) #2
          to label %try.success unwind label %finally

finally:                                          ; preds = %toElem.success, %postinvoke2
  %1 = landingpad { i8*, i32 }
          cleanup                                 ; [#uses = 1]
  %2 = extractvalue { i8*, i32 } %1, 0            ; [#uses = 1]
  call void @_D3std5stdio4File17LockingTextWriter10__aggrDtorMFNeZv(%std.stdio.File.LockingTextWriter* nonnull %w) #2
  br label %eh.resume

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

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__TQjTSQr5range__T11SortedRangeTAhVAyaa3_613c62VEQChQBr18SortedRangeOptionsi0ZQCiZQDkFNaNbNfQDiZQCm(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg) local_unnamed_addr #1 {
  %__r395 = alloca %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", align 8 ; [#uses = 4, size/byte = 16]
  %r_arg.fca.0.0.extract = extractvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg, 0, 0 ; [#uses = 3]
  %1 = icmp eq i64 %r_arg.fca.0.0.extract, 0      ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %forcond, %0
  %merge = phi { i64, i8* } [ zeroinitializer, %0 ], [ %2, %forcond ] ; [#uses = 1, type = { i64, i8* }]
  ret { i64, i8* } %merge

endif:                                            ; preds = %0
  %r_arg.fca.0.1.extract = extractvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg, 0, 1 ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 %r_arg.fca.0.0.extract) #2 ; [#uses = 3]
  %.ptr1 = extractvalue { i64, i8* } %2, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %2, 0         ; [#uses = 3]
  %r.sroa.0.0..sroa_idx = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r395, i64 0, i32 0, i32 0 ; [#uses = 2, type = i64*]
  store i64 %r_arg.fca.0.0.extract, i64* %r.sroa.0.0..sroa_idx, align 8
  %r.sroa.3.0..sroa_idx11 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r395, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %r_arg.fca.0.1.extract, i8** %r.sroa.3.0..sroa_idx11, align 8
  %3 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r395, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  br label %forcond

forcond:                                          ; preds = %bounds.ok, %endif
  %.len.i.i = phi i64 [ %.len.i.i.pr, %bounds.ok ], [ 1, %endif ] ; [#uses = 1, type = i64]
  %i.0 = phi i64 [ %7, %bounds.ok ], [ 0, %endif ] ; [#uses = 3, type = i64]
  %.not.i.i = icmp eq i64 %.len.i.i, 0            ; [#uses = 1]
  br i1 %.not.i.i, label %if, label %forbody

forbody:                                          ; preds = %forcond
  %4 = call i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi5frontMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %__r395) #1 ; [#uses = 1]
  %exitcond.not = icmp eq i64 %i.0, %.len         ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody
  %5 = load i8, i8* %4, align 1                   ; [#uses = 1]
  %6 = getelementptr inbounds i8, i8* %.ptr1, i64 %i.0 ; [#uses = 1, type = i8*]
  store i8 %5, i8* %6, align 1
  %7 = add i64 %i.0, 1                            ; [#uses = 1]
  call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %3) #1
  %.len.i.i.pr = load i64, i64* %r.sroa.0.0..sroa_idx, align 8 ; [#uses = 1]
  br label %forcond

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std9algorithm7sorting__T4sortVAyaa3_613c62VEQBtQBs8mutation12SwapStrategyi0TAhZQCdFNaNbNiNfQpZSQDs5range__T11SortedRangeTQBtVQDra3_613c62VEQFkQBs18SortedRangeOptionsi0ZQCj({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  tail call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %r_arg.fca.0.extract, { i64, i8* } %r_arg) #2
  %1 = tail call zeroext i1 @_D3std9algorithm7sorting__T8isSortedSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZb({ i64, i8* } %r_arg) #2 ; [#uses = 1]
  br i1 %1, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %0
  %input_arg.fca.1.extract.i.i = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %.fca.0.0.insert.i = insertvalue %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert.i, i8* %input_arg.fca.1.extract.i.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert.i

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 36, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.10, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1949) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__TQjTSQr5range__T11SortedRangeTAhVAyaa3_613e62VEQChQBr18SortedRangeOptionsi0ZQCiZQDkFNaNbNfQDiZQCm(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg) local_unnamed_addr #1 {
  %__r405 = alloca %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", align 8 ; [#uses = 4, size/byte = 16]
  %r_arg.fca.0.0.extract = extractvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg, 0, 0 ; [#uses = 3]
  %1 = icmp eq i64 %r_arg.fca.0.0.extract, 0      ; [#uses = 1]
  br i1 %1, label %if, label %endif

if:                                               ; preds = %forcond, %0
  %merge = phi { i64, i8* } [ zeroinitializer, %0 ], [ %2, %forcond ] ; [#uses = 1, type = { i64, i8* }]
  ret { i64, i8* } %merge

endif:                                            ; preds = %0
  %r_arg.fca.0.1.extract = extractvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %r_arg, 0, 1 ; [#uses = 1]
  %2 = tail call { i64, i8* } @_d_newarrayU(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ah6__initZ to %object.TypeInfo*), i64 %r_arg.fca.0.0.extract) #2 ; [#uses = 3]
  %.ptr1 = extractvalue { i64, i8* } %2, 1        ; [#uses = 1]
  %.len = extractvalue { i64, i8* } %2, 0         ; [#uses = 3]
  %r.sroa.0.0..sroa_idx = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r405, i64 0, i32 0, i32 0 ; [#uses = 2, type = i64*]
  store i64 %r_arg.fca.0.0.extract, i64* %r.sroa.0.0..sroa_idx, align 8
  %r.sroa.3.0..sroa_idx11 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r405, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %r_arg.fca.0.1.extract, i8** %r.sroa.3.0..sroa_idx11, align 8
  %3 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %__r405, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  br label %forcond

forcond:                                          ; preds = %bounds.ok, %endif
  %.len.i.i = phi i64 [ %.len.i.i.pr, %bounds.ok ], [ 1, %endif ] ; [#uses = 1, type = i64]
  %i.0 = phi i64 [ %7, %bounds.ok ], [ 0, %endif ] ; [#uses = 3, type = i64]
  %.not.i.i = icmp eq i64 %.len.i.i, 0            ; [#uses = 1]
  br i1 %.not.i.i, label %if, label %forbody

forbody:                                          ; preds = %forcond
  %4 = call i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi5frontMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %__r405) #1 ; [#uses = 1]
  %exitcond.not = icmp eq i64 %i.0, %.len         ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody
  %5 = load i8, i8* %4, align 1                   ; [#uses = 1]
  %6 = getelementptr inbounds i8, i8* %.ptr1, i64 %i.0 ; [#uses = 1, type = i8*]
  store i8 %5, i8* %6, align 1
  %7 = add i64 %i.0, 1                            ; [#uses = 1]
  call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %3) #1
  %.len.i.i.pr = load i64, i64* %r.sroa.0.0..sroa_idx, align 8 ; [#uses = 1]
  br label %forcond

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std9algorithm7sorting__T4sortVAyaa3_613e62VEQBtQBs8mutation12SwapStrategyi0TAhZQCdFNaNbNiNfQpZSQDs5range__T11SortedRangeTQBtVQDra3_613e62VEQFkQBs18SortedRangeOptionsi0ZQCj({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  tail call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %r_arg.fca.0.extract, { i64, i8* } %r_arg) #2
  %1 = tail call zeroext i1 @_D3std9algorithm7sorting__T8isSortedSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZb({ i64, i8* } %r_arg) #2 ; [#uses = 1]
  br i1 %1, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %0
  %input_arg.fca.1.extract.i.i = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %.fca.0.0.insert.i = insertvalue %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert.i, i8* %input_arg.fca.1.extract.i.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert.i

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 36, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.10, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1949) #6
  unreachable
}

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9exception__T7enforceZ__TQmTbZQrFNaNfbLAxaAyamZb(i64 %line_arg, { i64, i8* } %file_arg, { i8*, { i64, i8* } (i8*)* } %msg_arg, i1 zeroext %value_arg) local_unnamed_addr #1 {
  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) #10
  unreachable

endif:                                            ; preds = %0
  ret i1 true
}

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAyaZQlFNaNbNdNiNfMKQtZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #1 {
  %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 = 125]
; Function Attrs: cold noreturn uwtable
declare void @_d_arraybounds_index({ i64, i8* }, i32, i64, i64) local_unnamed_addr #6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range10primitives__T5emptyTAhZQkFNaNbNdNiNfMKQsZb({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #1 {
  %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]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %a_arg) local_unnamed_addr #1 {
  %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) #6
  unreachable
}

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

; [#uses = 4]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #1 {
  %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) #6
  unreachable
}

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std5range10primitives__T7popBackThZQlFNaNbNiNfMKANghZv({ i64, i8* }* dereferenceable(16) %a) local_unnamed_addr #1 {
  %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 = 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) #6
  unreachable
}

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range10primitives__T4backThZQiFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %a_arg) local_unnamed_addr #1 {
  %a_arg.fca.0.extract = extractvalue { i64, i8* } %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, i8* } %a_arg, 1 ; [#uses = 1]
  %2 = getelementptr inbounds i8, i8* %a_arg.fca.1.extract, i64 %1 ; [#uses = 1, type = i8*]
  ret i8* %2

assertFailed:                                     ; preds = %0
  tail call void @_d_assert_msg({ i64, i8* } { i64 55, i8* getelementptr inbounds ([56 x i8], [56 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 2518) #6
  unreachable
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %depth_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 5, size/byte = 16]
  %left = alloca { i64, i8* }, align 8            ; [#uses = 3, size/byte = 16]
  %right = alloca { i64, i8* }, align 8           ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 6, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 4, type = i8**]
  %1 = bitcast i8** %r_arg.fca.1.gep to i64*      ; [#uses = 1]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %left, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %left, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %4 = bitcast i8** %3 to i64*                    ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %right, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %right, i64 0, i32 1 ; [#uses = 2, type = i8**]
  br label %forcond

forcond:                                          ; preds = %endif52, %0
  %.len = phi i64 [ %.len54, %endif52 ], [ %r_arg.fca.0.extract, %0 ] ; [#uses = 4, type = i64]
  %storemerge = phi i8* [ %.ptr53, %endif52 ], [ %r_arg.fca.1.extract, %0 ] ; [#uses = 4, type = i8*]
  %depth.0 = phi i64 [ %condtmp.0.sroa.speculated, %endif52 ], [ %depth_arg, %0 ] ; [#uses = 4, type = i64]
  store i8* %storemerge, i8** %r_arg.fca.1.gep, align 8
  %7 = icmp ugt i64 %.len, 1024                   ; [#uses = 1]
  br i1 %7, label %forbody, label %endfor

forbody:                                          ; preds = %forcond
  %8 = icmp eq i64 %depth.0, 0                    ; [#uses = 1]
  br i1 %8, label %if, label %endif

if:                                               ; preds = %forbody
  %.fca.0.insert79 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert82 = insertvalue { i64, i8* } %.fca.0.insert79, i8* %storemerge, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i8* } %.fca.1.insert82) #2
  ret void

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

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

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

condend:                                          ; preds = %condfalse, %condtrue
  %condtmp.0.sroa.speculated = phi i64 [ %11, %condtrue ], [ %13, %condfalse ] ; [#uses = 2, type = i64]
  %.fca.0.insert85 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert88 = insertvalue { i64, i8* } %.fca.0.insert85, i8* %storemerge, 1 ; [#uses = 1]
  %14 = call i64 @_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZm({ i64, i8* } %.fca.1.insert88) #2 ; [#uses = 4]
  %.len2 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp = icmp ult i64 %14, %.len2          ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %condend
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %15 = getelementptr inbounds i8, i8* %.ptr, i64 %14 ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %15, align 1                 ; [#uses = 2]
  %17 = add i64 %.len2, -1                        ; [#uses = 1]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %17, i64 %14, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  %.len4 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %18 = add i64 %.len4, -1                        ; [#uses = 1]
  br label %forcond5

forcond5:                                         ; preds = %endif35, %bounds.ok
  %.len13 = phi i64 [ %.len4, %bounds.ok ], [ %.len13.pre, %endif35 ] ; [#uses = 7, type = i64]
  %lessI.0 = phi i64 [ -1, %bounds.ok ], [ %19, %endif35 ] ; [#uses = 2, type = i64]
  %greaterI.0 = phi i64 [ %18, %bounds.ok ], [ %26, %endif35 ] ; [#uses = 2, type = i64]
  %.ptr17 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  br label %forcond9

forcond9:                                         ; preds = %bounds.ok15, %forcond5
  %lessI.1 = phi i64 [ %lessI.0, %forcond5 ], [ %19, %bounds.ok15 ] ; [#uses = 2, type = i64]
  %19 = add i64 %lessI.1, 1                       ; [#uses = 14]
  %bounds.cmp14 = icmp ult i64 %19, %.len13       ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %forcond9
  %20 = getelementptr inbounds i8, i8* %.ptr17, i64 %19 ; [#uses = 1, type = i8*]
  %21 = load i8, i8* %20, align 1                 ; [#uses = 1]
  %22 = icmp ult i8 %21, %16                      ; [#uses = 1]
  br i1 %22, label %forcond9, label %endfor12

bounds.fail16:                                    ; preds = %forcond9
  %23 = add i64 %lessI.0, 1                       ; [#uses = 2]
  %24 = icmp ugt i64 %.len13, %23                 ; [#uses = 1]
  %umax = select i1 %24, i64 %.len13, i64 %23     ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2175, i64 %umax, i64 %.len13) #6
  unreachable

endfor12:                                         ; preds = %bounds.ok15
  %.not = icmp ugt i64 %19, %greaterI.0           ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %forcond18

forcond18:                                        ; preds = %endfor12, %bounds.ok26
  %greaterI.1 = phi i64 [ %26, %bounds.ok26 ], [ %greaterI.0, %endfor12 ] ; [#uses = 2, type = i64]
  %25 = icmp eq i64 %greaterI.1, %19              ; [#uses = 1]
  br i1 %25, label %endfor8, label %endif23

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

bounds.ok26:                                      ; preds = %endif23
  %27 = getelementptr inbounds i8, i8* %.ptr17, i64 %26 ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = icmp ult i8 %16, %28                      ; [#uses = 1]
  br i1 %29, 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.11, i32 0, i32 0) }, i32 2180, i64 %26, i64 %.len13) #6
  unreachable

endfor21:                                         ; preds = %bounds.ok26
  %.not99 = icmp ugt i64 %19, %26                 ; [#uses = 1]
  br i1 %.not99, label %assertFailed33, label %assertPassed32

assertPassed32:                                   ; preds = %endfor21
  %30 = icmp eq i64 %19, %26                      ; [#uses = 1]
  br i1 %30, label %endfor8, label %endif35

endif35:                                          ; preds = %assertPassed32
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %26, i64 %19, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  %.len13.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  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.14, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2182) #6
  unreachable

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

endfor8:                                          ; preds = %assertPassed32, %forcond18
  %31 = add i64 %.len13, -1                       ; [#uses = 1]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %19, i64 %31, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  %.len40 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp.up.not = icmp ugt i64 %19, %.len40  ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail39, label %bounds.ok38

bounds.ok38:                                      ; preds = %endfor8
  %.ptr41100 = load i64, i64* %1, align 8         ; [#uses = 2]
  store i64 %19, i64* %2, align 8
  store i64 %.ptr41100, i64* %4, align 8
  %32 = add i64 %lessI.1, 2                       ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len40, %32  ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail44, label %bounds.ok43

bounds.ok43:                                      ; preds = %bounds.ok38
  %33 = inttoptr i64 %.ptr41100 to i8*            ; [#uses = 1]
  %lowerbound48 = getelementptr inbounds i8, i8* %33, i64 %32 ; [#uses = 2, type = i8*]
  %34 = sub i64 %.len40, %32                      ; [#uses = 3]
  store i64 %34, i64* %5, align 8
  store i8* %lowerbound48, i8** %6, align 8
  %35 = icmp ugt i64 %34, %19                     ; [#uses = 1]
  br i1 %35, label %if51, label %endif52

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

endif52:                                          ; preds = %if51, %bounds.ok43
  %.fca.1.load = phi i8* [ %.fca.1.load.pre, %if51 ], [ %lowerbound48, %bounds.ok43 ] ; [#uses = 1, type = i8*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %if51 ], [ %34, %bounds.ok43 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %condtmp.0.sroa.speculated, { i64, i8* } %.fca.1.insert) #1
  %.ptr53 = load i8*, i8** %3, align 8            ; [#uses = 1]
  %.len54 = load i64, i64* %2, align 8            ; [#uses = 2]
  store i64 %.len54, i64* %r_arg.fca.0.gep, align 8
  br label %forcond

bounds.fail44:                                    ; preds = %bounds.ok38
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2188, i64 %32, i64 %.len40, i64 %.len40) #6
  unreachable

bounds.fail39:                                    ; preds = %endfor8
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2188, i64 0, i64 %19, i64 %.len40) #6
  unreachable

bounds.fail:                                      ; preds = %condend
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2166, i64 %14, i64 %.len2) #6
  unreachable

endfor:                                           ; preds = %forcond
  %.fca.0.insert91 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert94 = insertvalue { i64, i8* } %.fca.0.insert91, i8* %storemerge, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCyFNaNbNiNfQpZv({ i64, i8* } %.fca.1.insert94) #2
  ret void
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm7sorting__T8isSortedSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZb({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %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
  %__key386.0 = phi i64 [ 0, %endif ], [ %2, %bounds.ok4 ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %__key386.0, %1     ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %bounds.ok4

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T12assumeSortedVAyaa3_613c62TAhZQBfFNaNbNiNfQpZSQCiQCh__T11SortedRangeTQBqVQCha3_613c62VEQDxQDw18SortedRangeOptionsi0ZQCj({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %input_arg.fca.0.extract.i = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %input_arg.fca.1.extract.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi5emptyMFNaNbNdNiNfZb(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi4saveMFNaNbNdNiNfZSQDrQDq__TQDnTQDdVQDea3_613c62VQDei0ZQEo(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack3 = load i8*, i8** %.elt2, align 8      ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %.unpack, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %.unpack3, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi5frontMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %2) #1 ; [#uses = 1]
  ret i8* %3
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi8popFrontMFNaNbNiNfZv(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  tail call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %1) #1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi4backMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i8* @_D3std5range10primitives__T4backThZQiFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %2) #1 ; [#uses = 1]
  ret i8* %3
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi7popBackMFNaNbNiNfZv(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  tail call void @_D3std5range10primitives__T7popBackThZQlFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %1) #1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi7opIndexMFNaNbNcNiNfmZh(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %i_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %3 = getelementptr inbounds i8, i8* %.ptr, i64 %i_arg ; [#uses = 1, type = i8*]
  ret i8* %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.12, i32 0, i32 0) }, i32 10828, i64 %i_arg, i64 %.len) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi7opSliceMFNaNbNiNjNfmmZSQDwQDv__TQDsTQDiVQDja3_613c62VQDji0ZQEt(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %b_arg, i64 %a_arg) local_unnamed_addr #1 {
  %.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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %a_arg ; [#uses = 1, type = i8*]
  %3 = sub i64 %b_arg, %a_arg                     ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %3, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %lowerbound, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \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.12, i32 0, i32 0) }, i32 10840, i64 %a_arg, i64 %b_arg, i64 %.len) #6
  unreachable

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi9__mixin246lengthMFNaNbNdNiNfZm(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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, i8* } @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi7releaseMFNaNbNiNjNfZQCs(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  %2 = tail call { i64, i8* } @_D3std9algorithm8mutation__T15trustedMoveImplTAhZQvFNaNbNiNeMNkKQsZQv({ i64, i8* }* nonnull dereferenceable(16) %1) #2 ; [#uses = 1]
  ret { i64, i8* } %2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm8mutation__T4moveTAhZQjFNaNbNiNfMNkKQsZQv({ i64, i8* }* dereferenceable(16) %source) local_unnamed_addr #1 {
  %1 = tail call { i64, i8* } @_D3std9algorithm8mutation__T15trustedMoveImplTAhZQvFNaNbNiNeMNkKQsZQv({ i64, i8* }* nonnull dereferenceable(16) %source) #2 ; [#uses = 1]
  ret { i64, i8* } %1
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAhVAyaa3_613c62VEQBsQBr18SortedRangeOptionsi0ZQCi11__xopEqualsFKxSQDpQDo__TQDlTQDbVQDca3_613c62VQDci0ZQEmKxQBqZb(%"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %q, %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %p) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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 = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %p, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %.elt3 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack4, 0 ; [#uses = 1]
  %.elt5 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a<b\22, SortedRangeOptions.assumeSorted).SortedRange"* %q, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6 = load i8*, i8** %.elt5, align 8      ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack6, 1 ; [#uses = 1]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsThThZQoFNaNbNiNeMxAhMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #2 ; [#uses = 1]
  ret i1 %5
}

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 3]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 2, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 2, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %1 = icmp ult i64 %r_arg.fca.0.extract, 2       ; [#uses = 1]
  br i1 %1, label %if, label %endif

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

endif:                                            ; preds = %0
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T9buildHeapZQlFNaNbNiNfQBcZv({ i64, i8* } %r_arg) #2
  br label %forcond

forcond:                                          ; preds = %forbody, %endif
  %i.0.in = phi i64 [ %r_arg.fca.0.extract, %endif ], [ %i.0, %forbody ] ; [#uses = 1, type = i64]
  %i.0 = add i64 %i.0.in, -1                      ; [#uses = 4]
  %.not = icmp eq i64 %i.0, 0                     ; [#uses = 1]
  br i1 %.not, label %if, label %forbody

forbody:                                          ; preds = %forcond
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %i.0, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  %.fca.0.load6 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.0.insert7 = insertvalue { i64, i8* } undef, i64 %.fca.0.load6, 0 ; [#uses = 1]
  %.fca.1.load9 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert10 = insertvalue { i64, i8* } %.fca.0.insert7, i8* %.fca.1.load9, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %i.0, i64 0, { i64, i8* } %.fca.1.insert10) #2
  br label %forcond
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZm({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %.lval_copy_for_ImplicitByvalRewrite = alloca { i64, i8* }, align 8 ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %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__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmZQFeFNaNbNiNfQvmmmZv(i64 %4, i64 %1, i64 0, { i64, i8* } %r_arg) #2
  br label %endif4

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

endif:                                            ; preds = %0
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %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, i8* }, { i64, i8* }* %.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, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %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__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmTmTmZQFiFNaNbNiNfQzmmmmmZv(i64 %8, i64 %7, i64 %1, i64 %6, i64 0, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #2
  ret i64 %1
}

; [#uses = 92]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %i2_arg, i64 %i1_arg, { i64, i8* }* dereferenceable(16) %r) local_unnamed_addr #1 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %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, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %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 i8, i8* %.ptr, i64 %i1_arg ; [#uses = 2, type = i8*]
  %4 = getelementptr inbounds i8, i8* %.ptr, i64 %i2_arg ; [#uses = 2, type = i8*]
  %5 = load i8, i8* %3, align 1                   ; [#uses = 1]
  %6 = load i8, i8* %4, align 1                   ; [#uses = 1]
  store i8 %6, i8* %3, align 1
  store i8 %5, i8* %4, align 1
  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.16, i32 0, i32 0) }, i32 3105, i64 %i2_arg, i64 %.len) #6
  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.16, i32 0, i32 0) }, i32 3105, i64 %i1_arg, i64 %.len) #6
  unreachable
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T4swapTAhZQjFNaNbNiNeKQpKQsZv({ i64, i8* }* dereferenceable(16) %rhs, { i64, i8* }* dereferenceable(16) %lhs) local_unnamed_addr #1 {
  %1 = tail call zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* nonnull dereferenceable(16) %lhs, { i64, i8* }* nonnull dereferenceable(16) %lhs) #2 ; [#uses = 1]
  br i1 %1, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %0
  %2 = tail call zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* nonnull dereferenceable(16) %rhs, { i64, i8* }* nonnull dereferenceable(16) %rhs) #2 ; [#uses = 1]
  br i1 %2, label %assertFailed2, label %assertPassed1

assertPassed1:                                    ; preds = %assertPassed
  %3 = tail call zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* nonnull dereferenceable(16) %rhs, { i64, i8* }* nonnull dereferenceable(16) %lhs) #2 ; [#uses = 1]
  br i1 %3, label %assertFailed4, label %assertPassed3

assertPassed3:                                    ; preds = %assertPassed1
  %4 = tail call zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* nonnull dereferenceable(16) %lhs, { i64, i8* }* nonnull dereferenceable(16) %rhs) #2 ; [#uses = 1]
  br i1 %4, label %assertFailed6, label %assertPassed5

assertPassed5:                                    ; preds = %assertPassed3
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %lhs, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 2]
  %.ptr11 = load i64, i64* %6, align 8            ; [#uses = 1]
  %7 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %lhs, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len = load i64, i64* %7, align 8              ; [#uses = 1]
  %8 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %rhs, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %9 = bitcast i8** %8 to i64*                    ; [#uses = 2]
  %.ptr712 = load i64, i64* %9, align 8           ; [#uses = 1]
  %10 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %rhs, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %.len8 = load i64, i64* %10, align 8            ; [#uses = 1]
  store i64 %.len8, i64* %7, align 8
  store i64 %.ptr712, i64* %6, align 8
  store i64 %.len, i64* %10, align 8
  store i64 %.ptr11, i64* %9, align 8
  ret void

assertFailed6:                                    ; preds = %assertPassed3
  tail call void @_d_assert_msg({ i64, i8* } { i64 24, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.26, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.16, i32 0, i32 0) }, i32 2831) #6
  unreachable

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

assertFailed2:                                    ; preds = %assertPassed
  tail call void @_d_assert_msg({ i64, i8* } { i64 27, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.24, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.16, i32 0, i32 0) }, i32 2829) #6
  unreachable

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCyFNaNbNiNfQpZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 14, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 6]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 8, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 9]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 9, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  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, %if57, %if70, %bounds.ok62, %if32, %if45, %bounds.ok37, %0, %0, %bounds.ok137, %bounds.ok124, %if132, %bounds.ok5, %if
  ret void

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

if:                                               ; preds = %bounds.ok5
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

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

bounds.ok29:                                      ; preds = %bounds.ok17
  %11 = icmp ult i8 %7, %10                       ; [#uses = 1]
  br i1 %11, label %if32, label %else34

if32:                                             ; preds = %bounds.ok29
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

else34:                                           ; preds = %bounds.ok29
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len35 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp36 = icmp ugt i64 %.len35, 1         ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

bounds.ok37:                                      ; preds = %else34
  %.ptr39 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %12 = getelementptr inbounds i8, i8* %.ptr39, i64 1 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %.ptr39, align 1             ; [#uses = 1]
  %15 = icmp ult i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %if45, label %case1

if45:                                             ; preds = %bounds.ok37
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.fail38:                                    ; preds = %else34
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1701, i64 1, i64 %.len35) #6
  unreachable

bounds.ok49:                                      ; preds = %bounds.ok17
  %16 = icmp ult i8 %10, %7                       ; [#uses = 1]
  br i1 %16, label %if57, label %bounds.ok62

if57:                                             ; preds = %bounds.ok49
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok62:                                      ; preds = %bounds.ok49
  %17 = icmp ult i8 %6, %10                       ; [#uses = 1]
  br i1 %17, label %if70, label %case1

if70:                                             ; preds = %bounds.ok62
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok81:                                      ; preds = %0
  %18 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %19 = load i8, i8* %18, align 1                 ; [#uses = 1]
  %20 = load i8, i8* %r_arg.fca.1.extract, align 1 ; [#uses = 1]
  %21 = icmp ult i8 %19, %20                      ; [#uses = 1]
  br i1 %21, label %endif85, label %bounds.ok88

endif85:                                          ; preds = %bounds.ok81
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len86.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp87 = icmp ugt i64 %.len86.pre, 3     ; [#uses = 1]
  br i1 %bounds.cmp87, label %bounds.ok88, label %bounds.fail89

bounds.ok88:                                      ; preds = %bounds.ok81, %endif85
  %.len86260 = phi i64 [ %.len86.pre, %endif85 ], [ 4, %bounds.ok81 ] ; [#uses = 1, type = i64]
  %.ptr90 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %22 = getelementptr inbounds i8, i8* %.ptr90, i64 3 ; [#uses = 1, type = i8*]
  %23 = getelementptr inbounds i8, i8* %.ptr90, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %22, align 1                 ; [#uses = 1]
  %25 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %26 = icmp ult i8 %24, %25                      ; [#uses = 1]
  br i1 %26, label %endif97, label %bounds.ok100

endif97:                                          ; preds = %bounds.ok88
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len98.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp99 = icmp ugt i64 %.len98.pre, 2     ; [#uses = 1]
  br i1 %bounds.cmp99, label %bounds.ok100, label %bounds.fail101

bounds.ok100:                                     ; preds = %bounds.ok88, %endif97
  %.len98263 = phi i64 [ %.len98.pre, %endif97 ], [ %.len86260, %bounds.ok88 ] ; [#uses = 1, type = i64]
  %.ptr102 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %27 = getelementptr inbounds i8, i8* %.ptr102, i64 2 ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = load i8, i8* %.ptr102, align 1            ; [#uses = 1]
  %30 = icmp ult i8 %28, %29                      ; [#uses = 1]
  br i1 %30, label %if108, label %endif109

if108:                                            ; preds = %bounds.ok100
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len110.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  br label %endif109

endif109:                                         ; preds = %if108, %bounds.ok100
  %.len110 = phi i64 [ %.len110.pre, %if108 ], [ %.len98263, %bounds.ok100 ] ; [#uses = 2, type = i64]
  %bounds.cmp111 = icmp ugt i64 %.len110, 3       ; [#uses = 1]
  br i1 %bounds.cmp111, label %bounds.ok112, label %bounds.fail113

bounds.ok112:                                     ; preds = %endif109
  %.ptr114 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %31 = getelementptr inbounds i8, i8* %.ptr114, i64 3 ; [#uses = 1, type = i8*]
  %32 = getelementptr inbounds i8, i8* %.ptr114, i64 1 ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %31, align 1                 ; [#uses = 1]
  %34 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %35 = icmp ult i8 %33, %34                      ; [#uses = 1]
  br i1 %35, label %endif121, label %bounds.ok124

endif121:                                         ; preds = %bounds.ok112
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len122.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp123 = icmp ugt i64 %.len122.pre, 2   ; [#uses = 1]
  br i1 %bounds.cmp123, label %bounds.ok124, label %bounds.fail125

bounds.ok124:                                     ; preds = %bounds.ok112, %endif121
  %.ptr126 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %36 = getelementptr inbounds i8, i8* %.ptr126, i64 2 ; [#uses = 1, type = i8*]
  %37 = getelementptr inbounds i8, i8* %.ptr126, i64 1 ; [#uses = 1, type = i8*]
  %38 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %39 = load i8, i8* %37, align 1                 ; [#uses = 1]
  %40 = icmp ult i8 %38, %39                      ; [#uses = 1]
  br i1 %40, label %if132, label %case1

if132:                                            ; preds = %bounds.ok124
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok137:                                     ; preds = %0
  %41 = add i64 %r_arg.fca.0.extract, -5          ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %41 ; [#uses = 1, type = i8*]
  %42 = insertvalue { i64, i8* } { i64 5, i8* undef }, i8* %lowerbound, 1 ; [#uses = 1]
  tail call void @_D3std9algorithm7sorting__T5sort5SQBg10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCuFNaNbNiNfQpZv({ i64, i8* } %42) #2
  %43 = icmp eq i64 %r_arg.fca.0.extract, 5       ; [#uses = 1]
  br i1 %43, label %case1, label %assertPassed

bounds.fail125:                                   ; preds = %endif121
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1721, i64 2, i64 %.len122.pre) #6
  unreachable

bounds.fail113:                                   ; preds = %endif109
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1720, i64 3, i64 %.len110) #6
  unreachable

bounds.fail101:                                   ; preds = %endif97
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1719, i64 2, i64 %.len98.pre) #6
  unreachable

bounds.fail89:                                    ; preds = %endif85
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1718, i64 3, i64 %.len86.pre) #6
  unreachable

assertPassed:                                     ; preds = %bounds.ok137
  %44 = add i64 %r_arg.fca.0.extract, -6          ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %forinc, %assertPassed
  %.len153 = phi i64 [ %r_arg.fca.0.extract, %assertPassed ], [ %.len153.pre, %forinc ] ; [#uses = 5, type = i64]
  %i.0 = phi i64 [ %44, %assertPassed ], [ %61, %forinc ] ; [#uses = 6, type = i64]
  %45 = add nuw i64 %i.0, 1                       ; [#uses = 4]
  %bounds.cmp154 = icmp ult i64 %i.0, %.len153    ; [#uses = 1]
  br i1 %bounds.cmp154, label %bounds.ok155, label %bounds.fail156

bounds.ok155:                                     ; preds = %forcond
  %.ptr157 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 3]
  %46 = getelementptr inbounds i8, i8* %.ptr157, i64 %i.0 ; [#uses = 1, type = i8*]
  %47 = load i8, i8* %46, align 1                 ; [#uses = 3]
  %bounds.cmp159 = icmp ult i64 %45, %.len153     ; [#uses = 1]
  br i1 %bounds.cmp159, label %bounds.ok160, label %bounds.fail161

bounds.ok160:                                     ; preds = %bounds.ok155
  %48 = getelementptr inbounds i8, i8* %.ptr157, i64 %45 ; [#uses = 1, type = i8*]
  %49 = load i8, i8* %48, align 1                 ; [#uses = 2]
  %50 = icmp ult i8 %49, %47                      ; [#uses = 1]
  br i1 %50, label %dowhile, label %endif164

dowhile:                                          ; preds = %bounds.ok160, %bounds.ok178
  %51 = phi i8 [ %57, %bounds.ok178 ], [ %49, %bounds.ok160 ] ; [#uses = 1, type = i8]
  %.ptr169 = phi i8* [ %.ptr180, %bounds.ok178 ], [ %.ptr157, %bounds.ok160 ] ; [#uses = 1, type = i8*]
  %.len165 = phi i64 [ %.len175, %bounds.ok178 ], [ %.len153, %bounds.ok160 ] ; [#uses = 4, type = i64]
  %j.0 = phi i64 [ %54, %bounds.ok178 ], [ %45, %bounds.ok160 ] ; [#uses = 7, type = i64]
  %bounds.cmp166 = icmp ult i64 %j.0, %.len165    ; [#uses = 1]
  br i1 %bounds.cmp166, label %bounds.ok167, label %bounds.fail168

bounds.ok167:                                     ; preds = %dowhile
  %52 = add i64 %j.0, -1                          ; [#uses = 3]
  %bounds.cmp171 = icmp ult i64 %52, %.len165     ; [#uses = 1]
  br i1 %bounds.cmp171, label %bounds.ok172, label %bounds.fail173

bounds.ok172:                                     ; preds = %bounds.ok167
  %53 = getelementptr inbounds i8, i8* %.ptr169, i64 %52 ; [#uses = 1, type = i8*]
  store i8 %51, i8* %53, align 1
  %54 = add nuw i64 %j.0, 1                       ; [#uses = 3]
  %.len175 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %55 = icmp ult i64 %54, %.len175                ; [#uses = 1]
  br i1 %55, label %bounds.ok178, label %enddowhile

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.11, i32 0, i32 0) }, i32 1753, i64 %52, i64 %.len165) #6
  unreachable

bounds.fail168:                                   ; preds = %dowhile
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1753, i64 %j.0, i64 %.len165) #6
  unreachable

bounds.ok178:                                     ; preds = %bounds.ok172
  %.ptr180 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %56 = getelementptr inbounds i8, i8* %.ptr180, i64 %54 ; [#uses = 1, type = i8*]
  %57 = load i8, i8* %56, align 1                 ; [#uses = 2]
  %58 = icmp ult i8 %57, %47                      ; [#uses = 1]
  br i1 %58, label %dowhile, label %enddowhile

enddowhile:                                       ; preds = %bounds.ok172, %bounds.ok178
  %bounds.cmp182 = icmp ult i64 %j.0, %.len175    ; [#uses = 1]
  br i1 %bounds.cmp182, label %bounds.ok183, label %bounds.fail184

bounds.ok183:                                     ; preds = %enddowhile
  %.ptr185 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %59 = getelementptr inbounds i8, i8* %.ptr185, i64 %j.0 ; [#uses = 1, type = i8*]
  store i8 %47, i8* %59, align 1
  br label %endif164

bounds.fail184:                                   ; preds = %enddowhile
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1761, i64 %j.0, i64 %.len175) #6
  unreachable

endif164:                                         ; preds = %bounds.ok183, %bounds.ok160
  %60 = icmp eq i64 %i.0, 0                       ; [#uses = 1]
  br i1 %60, 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.11, i32 0, i32 0) }, i32 1748, i64 %45, i64 %.len153) #6
  unreachable

bounds.fail156:                                   ; preds = %forcond
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1744, i64 %i.0, i64 %.len153) #6
  unreachable

forinc:                                           ; preds = %endif164
  %61 = add i64 %i.0, -1                          ; [#uses = 1]
  %.len153.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  br label %forcond
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm10comparison__T3maxTiTmZQjFNaNbNiNfimZm(i64 %_param_1_arg, i32 %_param_0_arg) local_unnamed_addr #1 {
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 #1 {
  %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 #1 {
  %1 = sext i32 %a_arg to i64                     ; [#uses = 1]
  %2 = icmp ult i64 %1, %b_arg                    ; [#uses = 1]
  ret i1 %2
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T9buildHeapZQlFNaNbNiNfQBcZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %1 = lshr i64 %r_arg.fca.0.extract, 1           ; [#uses = 1]
  br label %forcond

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

forbody:                                          ; preds = %forcond
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T8siftDownZQkFNaNbNiNfQBbmymZv(i64 %r_arg.fca.0.extract, i64 %2, { i64, i8* } %r_arg) #2
  br label %forcond

endfor:                                           ; preds = %forcond
  %3 = tail call zeroext i1 @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T6isHeapZQiFNaNbNiNfQzZb({ i64, i8* } %r_arg) #2 ; [#uses = 1]
  br i1 %3, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %endfor
  ret void

assertFailed:                                     ; preds = %endfor
  tail call void @_d_assert_msg({ i64, i8* } { i64 15, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2239) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %end_arg, i64 %parent_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 5, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 3, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  br label %forcond

forcond:                                          ; preds = %bounds.ok5, %0
  %parent.0 = phi i64 [ %parent_arg, %0 ], [ %spec.select, %bounds.ok5 ] ; [#uses = 4, type = i64]
  %1 = shl i64 %parent.0, 1                       ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 6]
  %.not = icmp ult i64 %2, %end_arg               ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %forcond
  %3 = icmp eq i64 %2, %end_arg                   ; [#uses = 1]
  br i1 %3, label %if1, label %forcond11.preheader

if1:                                              ; preds = %if
  %4 = or i64 %1, 1                               ; [#uses = 2]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %4, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond11.preheader

forcond11.preheader:                              ; preds = %if, %if1
  %child10.0.ph = phi i64 [ %parent.0, %if ], [ %4, %if1 ] ; [#uses = 1, type = i64]
  br label %forcond11

endif:                                            ; preds = %forcond
  %5 = or i64 %1, 1                               ; [#uses = 4]
  %.len = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp = icmp ult i64 %2, %.len            ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %endif
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp4 = icmp ult i64 %5, %.len           ; [#uses = 1]
  br i1 %bounds.cmp4, label %bounds.ok5, label %bounds.fail6

bounds.ok5:                                       ; preds = %bounds.ok
  %6 = getelementptr inbounds i8, i8* %.ptr, i64 %2 ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds i8, i8* %.ptr, i64 %5 ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %10 = icmp ult i8 %8, %9                        ; [#uses = 1]
  %spec.select = select i1 %10, i64 %5, i64 %2    ; [#uses = 2]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %spec.select, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond

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

bounds.fail:                                      ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2307, i64 %2, i64 %.len) #6
  unreachable

forcond11:                                        ; preds = %forcond11.preheader, %endif26
  %child10.0 = phi i64 [ %13, %endif26 ], [ %child10.0.ph, %forcond11.preheader ] ; [#uses = 6, type = i64]
  %11 = icmp ugt i64 %child10.0, %parent_arg      ; [#uses = 1]
  br i1 %11, label %forbody12, label %endfor14

forbody12:                                        ; preds = %forcond11
  %12 = add i64 %child10.0, -1                    ; [#uses = 1]
  %13 = lshr i64 %12, 1                           ; [#uses = 5]
  %.len15 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp16 = icmp ult i64 %13, %.len15       ; [#uses = 1]
  br i1 %bounds.cmp16, label %bounds.ok17, label %bounds.fail18

bounds.ok17:                                      ; preds = %forbody12
  %.ptr19 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp21 = icmp ult i64 %child10.0, %.len15 ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

bounds.ok22:                                      ; preds = %bounds.ok17
  %14 = getelementptr inbounds i8, i8* %.ptr19, i64 %13 ; [#uses = 1, type = i8*]
  %15 = getelementptr inbounds i8, i8* %.ptr19, i64 %child10.0 ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %14, align 1                 ; [#uses = 1]
  %17 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %18 = icmp ult i8 %16, %17                      ; [#uses = 1]
  br i1 %18, label %endif26, label %endfor14

endif26:                                          ; preds = %bounds.ok22
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %child10.0, i64 %13, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond11

bounds.fail23:                                    ; preds = %bounds.ok17
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2316, i64 %child10.0, i64 %.len15) #6
  unreachable

bounds.fail18:                                    ; preds = %forbody12
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2316, i64 %13, i64 %.len15) #6
  unreachable

endfor14:                                         ; preds = %bounds.ok22, %forcond11
  ret void
}

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

forcond:                                          ; preds = %endif31, %0
  %parent.0 = phi i64 [ %parent_arg, %0 ], [ %spec.select, %endif31 ] ; [#uses = 9, type = i64]
  %1 = shl i64 %parent.0, 1                       ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 6]
  %.not = icmp ult i64 %2, %end_arg               ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %forcond
  %3 = icmp eq i64 %2, %end_arg                   ; [#uses = 1]
  br i1 %3, label %andand, label %endfor

andand:                                           ; preds = %if
  %.len = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp = icmp ult i64 %parent.0, %.len     ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %andand
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %4 = or i64 %1, 1                               ; [#uses = 4]
  %bounds.cmp2 = icmp ult i64 %4, %.len           ; [#uses = 1]
  br i1 %bounds.cmp2, label %bounds.ok3, label %bounds.fail4

bounds.ok3:                                       ; preds = %bounds.ok
  %5 = getelementptr inbounds i8, i8* %.ptr, i64 %parent.0 ; [#uses = 1, type = i8*]
  %6 = getelementptr inbounds i8, i8* %.ptr, i64 %4 ; [#uses = 1, type = i8*]
  %7 = load i8, i8* %5, align 1                   ; [#uses = 1]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = icmp ult i8 %7, %8                         ; [#uses = 1]
  br i1 %9, label %if6, label %endfor

bounds.fail4:                                     ; preds = %bounds.ok
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2265, i64 %4, i64 %.len) #6
  unreachable

bounds.fail:                                      ; preds = %andand
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2265, i64 %parent.0, i64 %.len) #6
  unreachable

if6:                                              ; preds = %bounds.ok3
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %4, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  br label %endfor

endif:                                            ; preds = %forcond
  %10 = or i64 %1, 1                              ; [#uses = 4]
  %.len8 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 8]
  %bounds.cmp9 = icmp ult i64 %2, %.len8          ; [#uses = 1]
  br i1 %bounds.cmp9, label %bounds.ok10, label %bounds.fail11

bounds.ok10:                                      ; preds = %endif
  %.ptr12 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 4]
  %bounds.cmp14 = icmp ult i64 %10, %.len8        ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %bounds.ok10
  %11 = getelementptr inbounds i8, i8* %.ptr12, i64 %2 ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr12, i64 %10 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ult i8 %13, %14                      ; [#uses = 1]
  %spec.select = select i1 %15, i64 %10, i64 %2   ; [#uses = 5]
  %bounds.cmp21 = icmp ult i64 %parent.0, %.len8  ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

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

bounds.ok27:                                      ; preds = %bounds.ok22
  %16 = getelementptr inbounds i8, i8* %.ptr12, i64 %parent.0 ; [#uses = 1, type = i8*]
  %17 = getelementptr inbounds i8, i8* %.ptr12, i64 %spec.select ; [#uses = 1, type = i8*]
  %18 = load i8, i8* %16, align 1                 ; [#uses = 1]
  %19 = load i8, i8* %17, align 1                 ; [#uses = 1]
  %20 = icmp ult i8 %18, %19                      ; [#uses = 1]
  br i1 %20, label %endif31, label %endfor

endif31:                                          ; preds = %bounds.ok27
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %spec.select, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #2
  br label %forcond

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

bounds.fail23:                                    ; preds = %bounds.ok15
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2271, i64 %parent.0, i64 %.len8) #6
  unreachable

bounds.fail16:                                    ; preds = %bounds.ok10
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2270, i64 %10, i64 %.len8) #6
  unreachable

bounds.fail11:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2270, i64 %2, i64 %.len8) #6
  unreachable

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

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

forcond:                                          ; preds = %endif, %0
  %__key381.0 = phi i64 [ 1, %0 ], [ %10, %endif ] ; [#uses = 4, type = i64]
  %parent.0 = phi i64 [ 0, %0 ], [ %9, %endif ]   ; [#uses = 4, type = i64]
  %exitcond.not = icmp eq i64 %__key381.0, %umax  ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %forbody

forbody:                                          ; preds = %forcond
  %bounds.cmp = icmp ult i64 %parent.0, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok4, label %bounds.fail

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

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

endif:                                            ; preds = %bounds.ok4
  %7 = and i64 %__key381.0, 1                     ; [#uses = 1]
  %8 = xor i64 %7, 1                              ; [#uses = 1]
  %9 = add i64 %8, %parent.0                      ; [#uses = 1]
  %10 = add i64 %__key381.0, 1                    ; [#uses = 1]
  br label %forcond

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmZQFeFNaNbNiNfQvmmmZv(i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 8, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 9]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 5]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 3, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %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 i8, i8* %r_arg.fca.1.extract, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %4 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %5 = load i8, i8* %3, align 1                   ; [#uses = 2]
  %6 = load i8, i8* %4, align 1                   ; [#uses = 3]
  %7 = icmp ult i8 %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 i8, i8* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %9 = load i8, i8* %8, align 1                   ; [#uses = 1]
  %10 = icmp ult i8 %6, %9                        ; [#uses = 1]
  br i1 %10, label %if21, label %else23

if21:                                             ; preds = %bounds.ok18
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

else23:                                           ; preds = %bounds.ok18
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len24 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp25 = icmp ugt i64 %.len24, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp25, label %bounds.ok26, label %bounds.fail27

bounds.ok26:                                      ; preds = %else23
  %.ptr28 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp30 = icmp ugt i64 %.len24, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp30, label %bounds.ok31, label %bounds.fail32

bounds.ok31:                                      ; preds = %bounds.ok26
  %11 = getelementptr inbounds i8, i8* %.ptr28, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr28, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ult i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %if34, label %endif

if34:                                             ; preds = %bounds.ok31
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

bounds.fail32:                                    ; preds = %bounds.ok26
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4280, i64 %_param_1_arg, i64 %.len24) #6
  unreachable

bounds.fail27:                                    ; preds = %else23
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4280, i64 %_param_2_arg, i64 %.len24) #6
  unreachable

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.11, i32 0, i32 0) }, i32 4272, i64 %_param_2_arg, i64 %r_arg.fca.0.extract) #6
  unreachable

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

bounds.ok43:                                      ; preds = %else
  %16 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %16, align 1                 ; [#uses = 2]
  %18 = icmp ult i8 %17, %6                       ; [#uses = 1]
  br i1 %18, label %if46, label %bounds.ok56

if46:                                             ; preds = %bounds.ok43
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

bounds.ok56:                                      ; preds = %bounds.ok43
  %19 = icmp ult i8 %5, %17                       ; [#uses = 1]
  br i1 %19, label %if59, label %endif

if59:                                             ; preds = %bounds.ok56
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

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

endif:                                            ; preds = %if46, %if59, %bounds.ok56, %if21, %if34, %bounds.ok31
  %.len61 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp62 = icmp ugt i64 %.len61, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp62, label %bounds.ok63, label %bounds.fail64

bounds.ok63:                                      ; preds = %endif
  %.ptr65 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 3]
  %bounds.cmp67 = icmp ugt i64 %.len61, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %bounds.ok63
  %20 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %21 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %22 = load i8, i8* %20, align 1                 ; [#uses = 2]
  %23 = load i8, i8* %21, align 1                 ; [#uses = 1]
  %24 = icmp ult i8 %22, %23                      ; [#uses = 1]
  br i1 %24, label %assertFailed72, label %assertPassed71

assertPassed71:                                   ; preds = %bounds.ok68
  %bounds.cmp74 = icmp ugt i64 %.len61, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp74, label %bounds.ok80, label %bounds.fail76

bounds.ok80:                                      ; preds = %assertPassed71
  %25 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %26 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %27 = icmp ult i8 %26, %22                      ; [#uses = 1]
  br i1 %27, label %assertFailed84, label %assertPassed83

assertPassed83:                                   ; preds = %bounds.ok80
  ret void

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

bounds.fail76:                                    ; preds = %assertPassed71
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4295, i64 %_param_3_arg, i64 %.len61) #6
  unreachable

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

bounds.fail69:                                    ; preds = %bounds.ok63
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4294, i64 %_param_1_arg, i64 %.len61) #6
  unreachable

bounds.fail64:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4294, i64 %_param_2_arg, i64 %.len61) #6
  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.11, i32 0, i32 0) }, i32 4270, i64 %_param_1_arg, i64 %r_arg.fca.0.extract) #6
  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.11, i32 0, i32 0) }, i32 4270, i64 %_param_3_arg, i64 %r_arg.fca.0.extract) #6
  unreachable

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmTmTmZQFiFNaNbNiNfQzmmmmmZv(i64 %_param_5_arg, i64 %_param_4_arg, i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* byval align 8 %r) local_unnamed_addr #1 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 6, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 6]
  %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, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 6, type = i8**]
  %.ptr = load i8*, i8** %9, align 8              ; [#uses = 2]
  %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 i8, i8* %.ptr, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %11 = getelementptr inbounds i8, i8* %.ptr, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %12 = load i8, i8* %10, align 1                 ; [#uses = 1]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = icmp ult i8 %12, %13                      ; [#uses = 1]
  br i1 %14, label %if, label %endif

if:                                               ; preds = %bounds.ok27
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len30.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %if, %bounds.ok27
  %.len30 = phi i64 [ %.len30.pre, %if ], [ %.len, %bounds.ok27 ] ; [#uses = 5, type = i64]
  %bounds.cmp31 = icmp ugt i64 %.len30, %_param_4_arg ; [#uses = 1]
  br i1 %bounds.cmp31, label %bounds.ok32, label %bounds.fail33

bounds.ok32:                                      ; preds = %endif
  %.ptr34 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp36 = icmp ugt i64 %.len30, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

bounds.ok37:                                      ; preds = %bounds.ok32
  %15 = getelementptr inbounds i8, i8* %.ptr34, i64 %_param_4_arg ; [#uses = 1, type = i8*]
  %16 = getelementptr inbounds i8, i8* %.ptr34, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %18 = load i8, i8* %16, align 1                 ; [#uses = 1]
  %19 = icmp ult i8 %17, %18                      ; [#uses = 1]
  br i1 %19, label %if40, label %endif41

if40:                                             ; preds = %bounds.ok37
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_4_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len42.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif41

endif41:                                          ; preds = %if40, %bounds.ok37
  %.len42 = phi i64 [ %.len42.pre, %if40 ], [ %.len30, %bounds.ok37 ] ; [#uses = 5, type = i64]
  %bounds.cmp43 = icmp ugt i64 %.len42, %_param_4_arg ; [#uses = 1]
  br i1 %bounds.cmp43, label %bounds.ok44, label %bounds.fail45

bounds.ok44:                                      ; preds = %endif41
  %.ptr46 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp48 = icmp ugt i64 %.len42, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp48, label %bounds.ok49, label %bounds.fail50

bounds.ok49:                                      ; preds = %bounds.ok44
  %20 = getelementptr inbounds i8, i8* %.ptr46, i64 %_param_4_arg ; [#uses = 1, type = i8*]
  %21 = getelementptr inbounds i8, i8* %.ptr46, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %22 = load i8, i8* %20, align 1                 ; [#uses = 1]
  %23 = load i8, i8* %21, align 1                 ; [#uses = 1]
  %24 = icmp ult i8 %22, %23                      ; [#uses = 1]
  br i1 %24, label %if52, label %endif53

if52:                                             ; preds = %bounds.ok49
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_4_arg, i64 %_param_3_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len54.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif53

endif53:                                          ; preds = %if52, %bounds.ok49
  %.len54 = phi i64 [ %.len54.pre, %if52 ], [ %.len42, %bounds.ok49 ] ; [#uses = 5, type = i64]
  %bounds.cmp55 = icmp ugt i64 %.len54, %_param_5_arg ; [#uses = 1]
  br i1 %bounds.cmp55, label %bounds.ok56, label %bounds.fail57

bounds.ok56:                                      ; preds = %endif53
  %.ptr58 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp60 = icmp ugt i64 %.len54, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp60, label %bounds.ok61, label %bounds.fail62

bounds.ok61:                                      ; preds = %bounds.ok56
  %25 = getelementptr inbounds i8, i8* %.ptr58, i64 %_param_5_arg ; [#uses = 1, type = i8*]
  %26 = getelementptr inbounds i8, i8* %.ptr58, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %27 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %28 = load i8, i8* %26, align 1                 ; [#uses = 1]
  %29 = icmp ult i8 %27, %28                      ; [#uses = 1]
  br i1 %29, label %if64, label %endif65

if64:                                             ; preds = %bounds.ok61
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_5_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len66.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif65

endif65:                                          ; preds = %if64, %bounds.ok61
  %.len66 = phi i64 [ %.len66.pre, %if64 ], [ %.len54, %bounds.ok61 ] ; [#uses = 6, type = i64]
  %bounds.cmp67 = icmp ugt i64 %.len66, %_param_5_arg ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %endif65
  %.ptr70 = load i8*, i8** %9, align 8            ; [#uses = 3]
  %bounds.cmp72 = icmp ugt i64 %.len66, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp72, label %bounds.ok73, label %bounds.fail74

bounds.ok73:                                      ; preds = %bounds.ok68
  %30 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_5_arg ; [#uses = 1, type = i8*]
  %31 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %32 = load i8, i8* %30, align 1                 ; [#uses = 1]
  %33 = load i8, i8* %31, align 1                 ; [#uses = 2]
  %34 = icmp ult i8 %32, %33                      ; [#uses = 1]
  br i1 %34, label %if76, label %bounds.ok92

if76:                                             ; preds = %bounds.ok73
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_5_arg, i64 %_param_3_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len78 = load i64, i64* %1, align 8            ; [#uses = 4]
  %bounds.cmp79 = icmp ugt i64 %.len78, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp79, label %bounds.ok80, label %bounds.fail81

bounds.ok80:                                      ; preds = %if76
  %.ptr82 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp84 = icmp ugt i64 %.len78, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp84, label %bounds.ok85, label %bounds.fail86

bounds.ok85:                                      ; preds = %bounds.ok80
  %35 = getelementptr inbounds i8, i8* %.ptr82, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %36 = getelementptr inbounds i8, i8* %.ptr82, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %35, align 1                 ; [#uses = 1]
  %38 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %39 = icmp ult i8 %37, %38                      ; [#uses = 1]
  br i1 %39, label %if88, label %endif77

if88:                                             ; preds = %bounds.ok85
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail86:                                    ; preds = %bounds.ok80
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4336, i64 %_param_1_arg, i64 %.len78) #6
  unreachable

bounds.fail81:                                    ; preds = %if76
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4336, i64 %_param_3_arg, i64 %.len78) #6
  unreachable

bounds.ok92:                                      ; preds = %bounds.ok73
  %bounds.cmp96 = icmp ugt i64 %.len66, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp96, label %bounds.ok97, label %bounds.fail98

bounds.ok97:                                      ; preds = %bounds.ok92
  %40 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %41 = load i8, i8* %40, align 1                 ; [#uses = 1]
  %42 = icmp ult i8 %33, %41                      ; [#uses = 1]
  br i1 %42, label %if100, label %endif77

if100:                                            ; preds = %bounds.ok97
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail98:                                    ; preds = %bounds.ok92
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4340, i64 %_param_2_arg, i64 %.len66) #6
  unreachable

endif77:                                          ; preds = %bounds.ok97, %if100, %bounds.ok85, %if88
  ret void

bounds.fail74:                                    ; preds = %bounds.ok68
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4333, i64 %_param_3_arg, i64 %.len66) #6
  unreachable

bounds.fail69:                                    ; preds = %endif65
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4333, i64 %_param_5_arg, i64 %.len66) #6
  unreachable

bounds.fail62:                                    ; preds = %bounds.ok56
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4332, i64 %_param_2_arg, i64 %.len54) #6
  unreachable

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

bounds.fail50:                                    ; preds = %bounds.ok44
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4327, i64 %_param_3_arg, i64 %.len42) #6
  unreachable

bounds.fail45:                                    ; preds = %endif41
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4327, i64 %_param_4_arg, i64 %.len42) #6
  unreachable

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

bounds.fail33:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4326, i64 %_param_4_arg, i64 %.len30) #6
  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.11, i32 0, i32 0) }, i32 4325, i64 %_param_1_arg, i64 %.len) #6
  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.11, i32 0, i32 0) }, i32 4325, i64 %_param_3_arg, i64 %.len) #6
  unreachable

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

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

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

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

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

; [#uses = 5]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* dereferenceable(16) %target, { i64, i8* }* dereferenceable(16) %source) local_unnamed_addr #1 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 1]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %3 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.ptr, 1  ; [#uses = 1]
  %5 = bitcast { i64, i8* }* %target to i8*       ; [#uses = 1]
  %6 = insertvalue { i64, i8* } { i64 16, i8* undef }, i8* %5, 1 ; [#uses = 1]
  %7 = tail call { i64, i8* } @_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf({ i64, i8* } %6, { i64, i8* } %4) #2 ; [#uses = 1]
  %.len1 = extractvalue { i64, i8* } %7, 0        ; [#uses = 1]
  %8 = icmp ne i64 %.len1, 0                      ; [#uses = 1]
  ret i1 %8
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std5array__T7overlapTvTvZQnFNaNbNiNeAvQcZQf({ i64, i8* } %b_arg, { i64, i8* } %a_arg) local_unnamed_addr #1 {
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 #1 {
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__T9binaryFunVAyaa3_613c62VQna1_61VQva1_62ZQBoTAhZQCuFNaNbNiNfQpZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 13, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 3]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 7, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 3]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 7, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %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 i8, i8* %r_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %3 = load i8, i8* %2, align 1                   ; [#uses = 1]
  %4 = load i8, i8* %r_arg.fca.1.extract, align 1 ; [#uses = 1]
  %5 = icmp ult i8 %3, %4                         ; [#uses = 1]
  br i1 %5, label %endif, label %bounds.ok9

endif:                                            ; preds = %bounds.ok4
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len7.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp8 = icmp ugt i64 %.len7.pre, 3       ; [#uses = 1]
  br i1 %bounds.cmp8, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %bounds.ok4, %endif
  %.len7196 = phi i64 [ %.len7.pre, %endif ], [ %r_arg.fca.0.extract, %bounds.ok4 ] ; [#uses = 1, type = i64]
  %.ptr11 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %6 = getelementptr inbounds i8, i8* %.ptr11, i64 3 ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds i8, i8* %.ptr11, i64 2 ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %10 = icmp ult i8 %8, %9                        ; [#uses = 1]
  br i1 %10, label %endif18, label %bounds.ok21

endif18:                                          ; preds = %bounds.ok9
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len19.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp20 = icmp ugt i64 %.len19.pre, 3     ; [#uses = 1]
  br i1 %bounds.cmp20, label %bounds.ok21, label %bounds.fail22

bounds.ok21:                                      ; preds = %bounds.ok9, %endif18
  %.len19199 = phi i64 [ %.len19.pre, %endif18 ], [ %.len7196, %bounds.ok9 ] ; [#uses = 1, type = i64]
  %.ptr23 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %11 = getelementptr inbounds i8, i8* %.ptr23, i64 3 ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr23, i64 1 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ult i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %endif30, label %bounds.ok33

endif30:                                          ; preds = %bounds.ok21
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len31.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp32 = icmp ugt i64 %.len31.pre, 1     ; [#uses = 1]
  br i1 %bounds.cmp32, label %bounds.ok33, label %bounds.fail34

bounds.ok33:                                      ; preds = %bounds.ok21, %endif30
  %.len31202 = phi i64 [ %.len31.pre, %endif30 ], [ %.len19199, %bounds.ok21 ] ; [#uses = 4, type = i64]
  %.ptr35 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 5]
  %16 = getelementptr inbounds i8, i8* %.ptr35, i64 1 ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %16, align 1                 ; [#uses = 3]
  %18 = load i8, i8* %.ptr35, align 1             ; [#uses = 1]
  %19 = icmp ult i8 %17, %18                      ; [#uses = 1]
  br i1 %19, label %assertFailed65, label %andand

andand:                                           ; preds = %bounds.ok33
  %bounds.cmp42 = icmp ugt i64 %.len31202, 3      ; [#uses = 1]
  br i1 %bounds.cmp42, label %bounds.ok43, label %bounds.fail44

bounds.ok43:                                      ; preds = %andand
  %20 = getelementptr inbounds i8, i8* %.ptr35, i64 3 ; [#uses = 1, type = i8*]
  %21 = load i8, i8* %20, align 1                 ; [#uses = 3]
  %22 = icmp ult i8 %21, %17                      ; [#uses = 1]
  br i1 %22, label %assertFailed65, label %bounds.ok55

bounds.fail44:                                    ; preds = %andand
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1821, i64 3, i64 %.len31202) #6
  unreachable

bounds.ok55:                                      ; preds = %bounds.ok43
  %23 = getelementptr inbounds i8, i8* %.ptr35, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = icmp ult i8 %21, %24                      ; [#uses = 1]
  br i1 %25, label %assertFailed65, label %assertPassed64

assertPassed64:                                   ; preds = %bounds.ok55
  %bounds.cmp67 = icmp ugt i64 %.len31202, 4      ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %assertPassed64
  %26 = getelementptr inbounds i8, i8* %.ptr35, i64 4 ; [#uses = 1, type = i8*]
  %27 = load i8, i8* %26, align 1                 ; [#uses = 2]
  %28 = icmp ult i8 %27, %17                      ; [#uses = 1]
  br i1 %28, label %if76, label %bounds.ok92

if76:                                             ; preds = %bounds.ok68
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 4, i64 3, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len78 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp79 = icmp ugt i64 %.len78, 1         ; [#uses = 1]
  br i1 %bounds.cmp79, label %bounds.ok80, label %bounds.fail81

bounds.ok80:                                      ; preds = %if76
  %.ptr82 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %29 = getelementptr inbounds i8, i8* %.ptr82, i64 1 ; [#uses = 1, type = i8*]
  %30 = load i8, i8* %29, align 1                 ; [#uses = 1]
  %31 = load i8, i8* %.ptr82, align 1             ; [#uses = 1]
  %32 = icmp ult i8 %30, %31                      ; [#uses = 1]
  br i1 %32, label %if88, label %endif77

if88:                                             ; preds = %bounds.ok80
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail81:                                    ; preds = %if76
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1829, i64 1, i64 %.len78) #6
  unreachable

bounds.ok92:                                      ; preds = %bounds.ok68
  %33 = icmp ult i8 %27, %21                      ; [#uses = 1]
  br i1 %33, label %if100, label %endif77

if100:                                            ; preds = %bounds.ok92
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 4, i64 3, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

endif77:                                          ; preds = %bounds.ok92, %if100, %bounds.ok80, %if88
  %.len102 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp103 = icmp ugt i64 %.len102, 1       ; [#uses = 1]
  br i1 %bounds.cmp103, label %bounds.ok104, label %bounds.fail105

bounds.ok104:                                     ; preds = %endif77
  %.ptr106 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 5]
  %34 = getelementptr inbounds i8, i8* %.ptr106, i64 1 ; [#uses = 1, type = i8*]
  %35 = load i8, i8* %34, align 1                 ; [#uses = 3]
  %36 = load i8, i8* %.ptr106, align 1            ; [#uses = 1]
  %37 = icmp ult i8 %35, %36                      ; [#uses = 1]
  br i1 %37, label %assertFailed139, label %andand112

andand112:                                        ; preds = %bounds.ok104
  %bounds.cmp115 = icmp ugt i64 %.len102, 3       ; [#uses = 1]
  br i1 %bounds.cmp115, label %bounds.ok116, label %bounds.fail117

bounds.ok116:                                     ; preds = %andand112
  %38 = getelementptr inbounds i8, i8* %.ptr106, i64 3 ; [#uses = 1, type = i8*]
  %39 = load i8, i8* %38, align 1                 ; [#uses = 3]
  %40 = icmp ult i8 %39, %35                      ; [#uses = 1]
  br i1 %40, label %assertFailed139, label %andand125

bounds.fail117:                                   ; preds = %andand112
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 3, i64 %.len102) #6
  unreachable

andand125:                                        ; preds = %bounds.ok116
  %bounds.cmp128 = icmp ugt i64 %.len102, 4       ; [#uses = 1]
  br i1 %bounds.cmp128, label %bounds.ok129, label %bounds.fail130

bounds.ok129:                                     ; preds = %andand125
  %41 = getelementptr inbounds i8, i8* %.ptr106, i64 4 ; [#uses = 1, type = i8*]
  %42 = load i8, i8* %41, align 1                 ; [#uses = 2]
  %43 = icmp ult i8 %42, %39                      ; [#uses = 1]
  br i1 %43, label %assertFailed139, label %bounds.ok142

bounds.fail130:                                   ; preds = %andand125
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 4, i64 %.len102) #6
  unreachable

bounds.ok142:                                     ; preds = %bounds.ok129
  %44 = getelementptr inbounds i8, i8* %.ptr106, i64 2 ; [#uses = 1, type = i8*]
  %45 = load i8, i8* %44, align 1                 ; [#uses = 3]
  %46 = icmp ult i8 %42, %45                      ; [#uses = 1]
  br i1 %46, label %assertFailed151, label %bounds.ok154

bounds.ok154:                                     ; preds = %bounds.ok142
  %47 = icmp ult i8 %45, %35                      ; [#uses = 1]
  br i1 %47, label %if162, label %bounds.ok179

if162:                                            ; preds = %bounds.ok154
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len165 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp166 = icmp ugt i64 %.len165, 1       ; [#uses = 1]
  br i1 %bounds.cmp166, label %bounds.ok167, label %bounds.fail168

bounds.ok167:                                     ; preds = %if162
  %.ptr169 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %48 = getelementptr inbounds i8, i8* %.ptr169, i64 1 ; [#uses = 1, type = i8*]
  %49 = load i8, i8* %48, align 1                 ; [#uses = 1]
  %50 = load i8, i8* %.ptr169, align 1            ; [#uses = 1]
  %51 = icmp ult i8 %49, %50                      ; [#uses = 1]
  br i1 %51, label %if175, label %endif163

if175:                                            ; preds = %bounds.ok167
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif163

bounds.fail168:                                   ; preds = %if162
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1846, i64 1, i64 %.len165) #6
  unreachable

bounds.ok179:                                     ; preds = %bounds.ok154
  %52 = icmp ult i8 %39, %45                      ; [#uses = 1]
  br i1 %52, label %if187, label %endif163

if187:                                            ; preds = %bounds.ok179
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif163

endif163:                                         ; preds = %bounds.ok179, %if187, %bounds.ok167, %if175
  ret void

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

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

bounds.fail105:                                   ; preds = %endif77
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 1, i64 %.len102) #6
  unreachable

bounds.fail69:                                    ; preds = %assertPassed64
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1825, i64 4, i64 %.len31202) #6
  unreachable

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

bounds.fail34:                                    ; preds = %endif30
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1821, i64 1, i64 %.len31.pre) #6
  unreachable

bounds.fail22:                                    ; preds = %endif18
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1816, i64 3, i64 %.len19.pre) #6
  unreachable

bounds.fail10:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1813, i64 3, i64 %.len7.pre) #6
  unreachable

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8internal8lifetime__T10emplaceRefThThThZQtFNaNbNiNfKhKhZv(i8* dereferenceable(1) %_param_1, i8* dereferenceable(1) %chunk) local_unnamed_addr #1 {
  store i8 0, i8* %chunk, align 1
  %1 = load i8, i8* %_param_1, align 1            ; [#uses = 1]
  store i8 %1, i8* %chunk, align 1
  ret void
}

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D4core8internal8lifetime__T18emplaceInitializerTSQBwQBuQBo__T10emplaceRefThThThZQtFKhKhZ1SZQCmFNaNbNiNeKQCeZv(%"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* dereferenceable(1) %chunk) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* %chunk, i64 0, i32 0 ; [#uses = 1, type = i8*]
  store i8 0, i8* %1, align 1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* @_D4core8internal8lifetime__T10emplaceRefThThThZQtFKhKhZ1S__T6__ctorZQiMFNaNbNcNiNfKhZSQDgQDeQCy__TQCsThThThZQDcFKhKhZQCk(%"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* nonnull returned %.this_arg, i8* dereferenceable(1) %_param_0) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S", %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = i8*]
  %2 = load i8, i8* %_param_0, align 1            ; [#uses = 1]
  store i8 %2, i8* %1, align 1
  ret %"core.internal.lifetime.emplaceRef!(ubyte, ubyte, ubyte).emplaceRef.S"* %.this_arg
}

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %depth_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 5, size/byte = 16]
  %left = alloca { i64, i8* }, align 8            ; [#uses = 3, size/byte = 16]
  %right = alloca { i64, i8* }, align 8           ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 6, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 4, type = i8**]
  %1 = bitcast i8** %r_arg.fca.1.gep to i64*      ; [#uses = 1]
  %2 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %left, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %left, i64 0, i32 1 ; [#uses = 2, type = i8**]
  %4 = bitcast i8** %3 to i64*                    ; [#uses = 1]
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %right, i64 0, i32 0 ; [#uses = 2, type = i64*]
  %6 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %right, i64 0, i32 1 ; [#uses = 2, type = i8**]
  br label %forcond

forcond:                                          ; preds = %endif52, %0
  %.len = phi i64 [ %.len54, %endif52 ], [ %r_arg.fca.0.extract, %0 ] ; [#uses = 4, type = i64]
  %storemerge = phi i8* [ %.ptr53, %endif52 ], [ %r_arg.fca.1.extract, %0 ] ; [#uses = 4, type = i8*]
  %depth.0 = phi i64 [ %condtmp.0.sroa.speculated, %endif52 ], [ %depth_arg, %0 ] ; [#uses = 4, type = i64]
  store i8* %storemerge, i8** %r_arg.fca.1.gep, align 8
  %7 = icmp ugt i64 %.len, 1024                   ; [#uses = 1]
  br i1 %7, label %forbody, label %endfor

forbody:                                          ; preds = %forcond
  %8 = icmp eq i64 %depth.0, 0                    ; [#uses = 1]
  br i1 %8, label %if, label %endif

if:                                               ; preds = %forbody
  %.fca.0.insert79 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert82 = insertvalue { i64, i8* } %.fca.0.insert79, i8* %storemerge, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i8* } %.fca.1.insert82) #2
  ret void

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

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

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

condend:                                          ; preds = %condfalse, %condtrue
  %condtmp.0.sroa.speculated = phi i64 [ %11, %condtrue ], [ %13, %condfalse ] ; [#uses = 2, type = i64]
  %.fca.0.insert85 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert88 = insertvalue { i64, i8* } %.fca.0.insert85, i8* %storemerge, 1 ; [#uses = 1]
  %14 = call i64 @_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZm({ i64, i8* } %.fca.1.insert88) #2 ; [#uses = 4]
  %.len2 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp = icmp ult i64 %14, %.len2          ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %condend
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %15 = getelementptr inbounds i8, i8* %.ptr, i64 %14 ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %15, align 1                 ; [#uses = 2]
  %17 = add i64 %.len2, -1                        ; [#uses = 1]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %17, i64 %14, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len4 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %18 = add i64 %.len4, -1                        ; [#uses = 1]
  br label %forcond5

forcond5:                                         ; preds = %endif35, %bounds.ok
  %.len13 = phi i64 [ %.len4, %bounds.ok ], [ %.len13.pre, %endif35 ] ; [#uses = 7, type = i64]
  %lessI.0 = phi i64 [ -1, %bounds.ok ], [ %19, %endif35 ] ; [#uses = 2, type = i64]
  %greaterI.0 = phi i64 [ %18, %bounds.ok ], [ %26, %endif35 ] ; [#uses = 2, type = i64]
  %.ptr17 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  br label %forcond9

forcond9:                                         ; preds = %bounds.ok15, %forcond5
  %lessI.1 = phi i64 [ %lessI.0, %forcond5 ], [ %19, %bounds.ok15 ] ; [#uses = 2, type = i64]
  %19 = add i64 %lessI.1, 1                       ; [#uses = 14]
  %bounds.cmp14 = icmp ult i64 %19, %.len13       ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %forcond9
  %20 = getelementptr inbounds i8, i8* %.ptr17, i64 %19 ; [#uses = 1, type = i8*]
  %21 = load i8, i8* %20, align 1                 ; [#uses = 1]
  %22 = icmp ugt i8 %21, %16                      ; [#uses = 1]
  br i1 %22, label %forcond9, label %endfor12

bounds.fail16:                                    ; preds = %forcond9
  %23 = add i64 %lessI.0, 1                       ; [#uses = 2]
  %24 = icmp ugt i64 %.len13, %23                 ; [#uses = 1]
  %umax = select i1 %24, i64 %.len13, i64 %23     ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2175, i64 %umax, i64 %.len13) #6
  unreachable

endfor12:                                         ; preds = %bounds.ok15
  %.not = icmp ugt i64 %19, %greaterI.0           ; [#uses = 1]
  br i1 %.not, label %assertFailed, label %forcond18

forcond18:                                        ; preds = %endfor12, %bounds.ok26
  %greaterI.1 = phi i64 [ %26, %bounds.ok26 ], [ %greaterI.0, %endfor12 ] ; [#uses = 2, type = i64]
  %25 = icmp eq i64 %greaterI.1, %19              ; [#uses = 1]
  br i1 %25, label %endfor8, label %endif23

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

bounds.ok26:                                      ; preds = %endif23
  %27 = getelementptr inbounds i8, i8* %.ptr17, i64 %26 ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = icmp ugt i8 %16, %28                      ; [#uses = 1]
  br i1 %29, 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.11, i32 0, i32 0) }, i32 2180, i64 %26, i64 %.len13) #6
  unreachable

endfor21:                                         ; preds = %bounds.ok26
  %.not99 = icmp ugt i64 %19, %26                 ; [#uses = 1]
  br i1 %.not99, label %assertFailed33, label %assertPassed32

assertPassed32:                                   ; preds = %endfor21
  %30 = icmp eq i64 %19, %26                      ; [#uses = 1]
  br i1 %30, label %endfor8, label %endif35

endif35:                                          ; preds = %assertPassed32
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %26, i64 %19, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len13.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  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.14, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2182) #6
  unreachable

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

endfor8:                                          ; preds = %assertPassed32, %forcond18
  %31 = add i64 %.len13, -1                       ; [#uses = 1]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %19, i64 %31, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len40 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp.up.not = icmp ugt i64 %19, %.len40  ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail39, label %bounds.ok38

bounds.ok38:                                      ; preds = %endfor8
  %.ptr41100 = load i64, i64* %1, align 8         ; [#uses = 2]
  store i64 %19, i64* %2, align 8
  store i64 %.ptr41100, i64* %4, align 8
  %32 = add i64 %lessI.1, 2                       ; [#uses = 4]
  %bounds.cmp.lo.not = icmp ult i64 %.len40, %32  ; [#uses = 1]
  br i1 %bounds.cmp.lo.not, label %bounds.fail44, label %bounds.ok43

bounds.ok43:                                      ; preds = %bounds.ok38
  %33 = inttoptr i64 %.ptr41100 to i8*            ; [#uses = 1]
  %lowerbound48 = getelementptr inbounds i8, i8* %33, i64 %32 ; [#uses = 2, type = i8*]
  %34 = sub i64 %.len40, %32                      ; [#uses = 3]
  store i64 %34, i64* %5, align 8
  store i8* %lowerbound48, i8** %6, align 8
  %35 = icmp ugt i64 %34, %19                     ; [#uses = 1]
  br i1 %35, label %if51, label %endif52

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

endif52:                                          ; preds = %if51, %bounds.ok43
  %.fca.1.load = phi i8* [ %.fca.1.load.pre, %if51 ], [ %lowerbound48, %bounds.ok43 ] ; [#uses = 1, type = i8*]
  %.fca.0.load = phi i64 [ %.fca.0.load.pre, %if51 ], [ %34, %bounds.ok43 ] ; [#uses = 1, type = i64]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.insert = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T13quickSortImplSQBp10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQDdFNaNbNiNfQpmZv(i64 %condtmp.0.sroa.speculated, { i64, i8* } %.fca.1.insert) #1
  %.ptr53 = load i8*, i8** %3, align 8            ; [#uses = 1]
  %.len54 = load i64, i64* %2, align 8            ; [#uses = 2]
  store i64 %.len54, i64* %r_arg.fca.0.gep, align 8
  br label %forcond

bounds.fail44:                                    ; preds = %bounds.ok38
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2188, i64 %32, i64 %.len40, i64 %.len40) #6
  unreachable

bounds.fail39:                                    ; preds = %endfor8
  call void @_d_arraybounds_slice({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2188, i64 0, i64 %19, i64 %.len40) #6
  unreachable

bounds.fail:                                      ; preds = %condend
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2166, i64 %14, i64 %.len2) #6
  unreachable

endfor:                                           ; preds = %forcond
  %.fca.0.insert91 = insertvalue { i64, i8* } undef, i64 %.len, 0 ; [#uses = 1]
  %.fca.1.insert94 = insertvalue { i64, i8* } %.fca.0.insert91, i8* %storemerge, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCyFNaNbNiNfQpZv({ i64, i8* } %.fca.1.insert94) #2
  ret void
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std9algorithm7sorting__T8isSortedSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZb({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %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
  %__key398.0 = phi i64 [ 0, %endif ], [ %2, %bounds.ok4 ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %__key398.0, %1     ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %bounds.ok4

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T12assumeSortedVAyaa3_613e62TAhZQBfFNaNbNiNfQpZSQCiQCh__T11SortedRangeTQBqVQCha3_613e62VEQDxQDw18SortedRangeOptionsi0ZQCj({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %input_arg.fca.0.extract.i = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %input_arg.fca.1.extract.i = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %input_arg.fca.1.extract.i, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi5emptyMFNaNbNdNiNfZb(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi4saveMFNaNbNdNiNfZSQDrQDq__TQDnTQDdVQDea3_613e62VQDei0ZQEo(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack3 = load i8*, i8** %.elt2, align 8      ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %.unpack, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %.unpack3, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.1.insert
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi5frontMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i8* @_D3std5range10primitives__T5frontThZQjFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %2) #1 ; [#uses = 1]
  ret i8* %3
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi8popFrontMFNaNbNiNfZv(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  tail call void @_D3std5range10primitives__T8popFrontThZQmFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %1) #1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi4backMFNaNbNcNdNiNfZh(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %3 = tail call i8* @_D3std5range10primitives__T4backThZQiFNaNbNcNdNiNfMNkANghZNgh({ i64, i8* } %2) #1 ; [#uses = 1]
  ret i8* %3
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr void @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi7popBackMFNaNbNiNfZv(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  tail call void @_D3std5range10primitives__T7popBackThZQlFNaNbNiNfMKANghZv({ i64, i8* }* nonnull dereferenceable(16) %1) #1
  ret void
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i8* @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi7opIndexMFNaNbNcNiNfmZh(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %i_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %3 = getelementptr inbounds i8, i8* %.ptr, i64 %i_arg ; [#uses = 1, type = i8*]
  ret i8* %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.12, i32 0, i32 0) }, i32 10828, i64 %i_arg, i64 %.len) #6
  unreachable
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi7opSliceMFNaNbNiNjNfmmZSQDwQDv__TQDsTQDiVQDja3_613e62VQDji0ZQEt(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg, i64 %b_arg, i64 %a_arg) local_unnamed_addr #1 {
  %.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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.ptr = load i8*, i8** %2, align 8              ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %.ptr, i64 %a_arg ; [#uses = 1, type = i8*]
  %3 = sub i64 %b_arg, %a_arg                     ; [#uses = 1]
  %.fca.0.0.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" undef, i64 %3, 0, 0 ; [#uses = 1]
  %.fca.0.1.insert = insertvalue %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange" %.fca.0.0.insert, i8* %lowerbound, 0, 1 ; [#uses = 1]
  ret %"std.range.SortedRange!(ubyte[], \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.12, i32 0, i32 0) }, i32 10840, i64 %a_arg, i64 %b_arg, i64 %.len) #6
  unreachable

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i64 @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi9__mixin246lengthMFNaNbNdNiNfZm(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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, i8* } @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi7releaseMFNaNbNiNjNfZQCs(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* nonnull %.this_arg) local_unnamed_addr #1 {
  %1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %.this_arg, i64 0, i32 0 ; [#uses = 1, type = { i64, i8* }*]
  %2 = tail call { i64, i8* } @_D3std9algorithm8mutation__T15trustedMoveImplTAhZQvFNaNbNiNeMNkKQsZQv({ i64, i8* }* nonnull dereferenceable(16) %1) #2 ; [#uses = 1]
  ret { i64, i8* } %2
}

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr zeroext i1 @_D3std5range__T11SortedRangeTAhVAyaa3_613e62VEQBsQBr18SortedRangeOptionsi0ZQCi11__xopEqualsFKxSQDpQDo__TQDlTQDbVQDca3_613e62VQDci0ZQEmKxQBqZb(%"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %q, %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* dereferenceable(16) %p) local_unnamed_addr #1 {
  %.elt = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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 = 1]
  %1 = insertvalue { i64, i8* } undef, i64 %.unpack, 0 ; [#uses = 1]
  %.elt1 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %p, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack2 = load i8*, i8** %.elt1, align 8      ; [#uses = 1]
  %2 = insertvalue { i64, i8* } %1, i8* %.unpack2, 1 ; [#uses = 1]
  %.elt3 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \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]
  %3 = insertvalue { i64, i8* } undef, i64 %.unpack4, 0 ; [#uses = 1]
  %.elt5 = getelementptr inbounds %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange", %"std.range.SortedRange!(ubyte[], \22a>b\22, SortedRangeOptions.assumeSorted).SortedRange"* %q, i64 0, i32 0, i32 1 ; [#uses = 1, type = i8**]
  %.unpack6 = load i8*, i8** %.elt5, align 8      ; [#uses = 1]
  %4 = insertvalue { i64, i8* } %3, i8* %.unpack6, 1 ; [#uses = 1]
  %5 = tail call zeroext i1 @_D4core8internal5array8equality__T8__equalsThThZQoFNaNbNiNeMxAhMxQeZb({ i64, i8* } %4, { i64, i8* } %2) #2 ; [#uses = 1]
  ret i1 %5
}

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T8heapSortZQkFNaNbNiNfQBbZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 3]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 2, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 2, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %1 = icmp ult i64 %r_arg.fca.0.extract, 2       ; [#uses = 1]
  br i1 %1, label %if, label %endif

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

endif:                                            ; preds = %0
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T9buildHeapZQlFNaNbNiNfQBcZv({ i64, i8* } %r_arg) #2
  br label %forcond

forcond:                                          ; preds = %forbody, %endif
  %i.0.in = phi i64 [ %r_arg.fca.0.extract, %endif ], [ %i.0, %forbody ] ; [#uses = 1, type = i64]
  %i.0 = add i64 %i.0.in, -1                      ; [#uses = 4]
  %.not = icmp eq i64 %i.0, 0                     ; [#uses = 1]
  br i1 %.not, label %if, label %forbody

forbody:                                          ; preds = %forcond
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %i.0, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.fca.0.load6 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.0.insert7 = insertvalue { i64, i8* } undef, i64 %.fca.0.load6, 0 ; [#uses = 1]
  %.fca.1.load9 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert10 = insertvalue { i64, i8* } %.fca.0.insert7, i8* %.fca.1.load9, 1 ; [#uses = 1]
  call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %i.0, i64 0, { i64, i8* } %.fca.1.insert10) #2
  br label %forcond
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i64 @_D3std9algorithm7sorting__T8getPivotSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCxFNaNbNiNfQpZm({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %.lval_copy_for_ImplicitByvalRewrite = alloca { i64, i8* }, align 8 ; [#uses = 3, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %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__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmZQFeFNaNbNiNfQvmmmZv(i64 %4, i64 %1, i64 0, { i64, i8* } %r_arg) #2
  br label %endif4

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

endif:                                            ; preds = %0
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %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, i8* }, { i64, i8* }* %.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, i8* }, { i64, i8* }* %.lval_copy_for_ImplicitByvalRewrite, i64 0, i32 1 ; [#uses = 1, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %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__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmTmTmZQFiFNaNbNiNfQzmmmmmZv(i64 %8, i64 %7, i64 %1, i64 %6, i64 0, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #2
  ret i64 %1
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T9shortSortSQBk10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCyFNaNbNiNfQpZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 14, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 6]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 8, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 9]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 9, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  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, %if57, %if70, %bounds.ok62, %if32, %if45, %bounds.ok37, %0, %0, %bounds.ok137, %bounds.ok124, %if132, %bounds.ok5, %if
  ret void

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

if:                                               ; preds = %bounds.ok5
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

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

bounds.ok29:                                      ; preds = %bounds.ok17
  %11 = icmp ugt i8 %7, %10                       ; [#uses = 1]
  br i1 %11, label %if32, label %else34

if32:                                             ; preds = %bounds.ok29
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

else34:                                           ; preds = %bounds.ok29
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len35 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp36 = icmp ugt i64 %.len35, 1         ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

bounds.ok37:                                      ; preds = %else34
  %.ptr39 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %12 = getelementptr inbounds i8, i8* %.ptr39, i64 1 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %.ptr39, align 1             ; [#uses = 1]
  %15 = icmp ugt i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %if45, label %case1

if45:                                             ; preds = %bounds.ok37
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.fail38:                                    ; preds = %else34
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1701, i64 1, i64 %.len35) #6
  unreachable

bounds.ok49:                                      ; preds = %bounds.ok17
  %16 = icmp ugt i8 %10, %7                       ; [#uses = 1]
  br i1 %16, label %if57, label %bounds.ok62

if57:                                             ; preds = %bounds.ok49
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok62:                                      ; preds = %bounds.ok49
  %17 = icmp ugt i8 %6, %10                       ; [#uses = 1]
  br i1 %17, label %if70, label %case1

if70:                                             ; preds = %bounds.ok62
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok81:                                      ; preds = %0
  %18 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %19 = load i8, i8* %18, align 1                 ; [#uses = 1]
  %20 = load i8, i8* %r_arg.fca.1.extract, align 1 ; [#uses = 1]
  %21 = icmp ugt i8 %19, %20                      ; [#uses = 1]
  br i1 %21, label %endif85, label %bounds.ok88

endif85:                                          ; preds = %bounds.ok81
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len86.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp87 = icmp ugt i64 %.len86.pre, 3     ; [#uses = 1]
  br i1 %bounds.cmp87, label %bounds.ok88, label %bounds.fail89

bounds.ok88:                                      ; preds = %bounds.ok81, %endif85
  %.len86260 = phi i64 [ %.len86.pre, %endif85 ], [ 4, %bounds.ok81 ] ; [#uses = 1, type = i64]
  %.ptr90 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %22 = getelementptr inbounds i8, i8* %.ptr90, i64 3 ; [#uses = 1, type = i8*]
  %23 = getelementptr inbounds i8, i8* %.ptr90, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %22, align 1                 ; [#uses = 1]
  %25 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %26 = icmp ugt i8 %24, %25                      ; [#uses = 1]
  br i1 %26, label %endif97, label %bounds.ok100

endif97:                                          ; preds = %bounds.ok88
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len98.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp99 = icmp ugt i64 %.len98.pre, 2     ; [#uses = 1]
  br i1 %bounds.cmp99, label %bounds.ok100, label %bounds.fail101

bounds.ok100:                                     ; preds = %bounds.ok88, %endif97
  %.len98263 = phi i64 [ %.len98.pre, %endif97 ], [ %.len86260, %bounds.ok88 ] ; [#uses = 1, type = i64]
  %.ptr102 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %27 = getelementptr inbounds i8, i8* %.ptr102, i64 2 ; [#uses = 1, type = i8*]
  %28 = load i8, i8* %27, align 1                 ; [#uses = 1]
  %29 = load i8, i8* %.ptr102, align 1            ; [#uses = 1]
  %30 = icmp ugt i8 %28, %29                      ; [#uses = 1]
  br i1 %30, label %if108, label %endif109

if108:                                            ; preds = %bounds.ok100
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len110.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  br label %endif109

endif109:                                         ; preds = %if108, %bounds.ok100
  %.len110 = phi i64 [ %.len110.pre, %if108 ], [ %.len98263, %bounds.ok100 ] ; [#uses = 2, type = i64]
  %bounds.cmp111 = icmp ugt i64 %.len110, 3       ; [#uses = 1]
  br i1 %bounds.cmp111, label %bounds.ok112, label %bounds.fail113

bounds.ok112:                                     ; preds = %endif109
  %.ptr114 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %31 = getelementptr inbounds i8, i8* %.ptr114, i64 3 ; [#uses = 1, type = i8*]
  %32 = getelementptr inbounds i8, i8* %.ptr114, i64 1 ; [#uses = 1, type = i8*]
  %33 = load i8, i8* %31, align 1                 ; [#uses = 1]
  %34 = load i8, i8* %32, align 1                 ; [#uses = 1]
  %35 = icmp ugt i8 %33, %34                      ; [#uses = 1]
  br i1 %35, label %endif121, label %bounds.ok124

endif121:                                         ; preds = %bounds.ok112
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len122.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp123 = icmp ugt i64 %.len122.pre, 2   ; [#uses = 1]
  br i1 %bounds.cmp123, label %bounds.ok124, label %bounds.fail125

bounds.ok124:                                     ; preds = %bounds.ok112, %endif121
  %.ptr126 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %36 = getelementptr inbounds i8, i8* %.ptr126, i64 2 ; [#uses = 1, type = i8*]
  %37 = getelementptr inbounds i8, i8* %.ptr126, i64 1 ; [#uses = 1, type = i8*]
  %38 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %39 = load i8, i8* %37, align 1                 ; [#uses = 1]
  %40 = icmp ugt i8 %38, %39                      ; [#uses = 1]
  br i1 %40, label %if132, label %case1

if132:                                            ; preds = %bounds.ok124
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %case1

bounds.ok137:                                     ; preds = %0
  %41 = add i64 %r_arg.fca.0.extract, -5          ; [#uses = 1]
  %lowerbound = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %41 ; [#uses = 1, type = i8*]
  %42 = insertvalue { i64, i8* } { i64 5, i8* undef }, i8* %lowerbound, 1 ; [#uses = 1]
  tail call void @_D3std9algorithm7sorting__T5sort5SQBg10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCuFNaNbNiNfQpZv({ i64, i8* } %42) #2
  %43 = icmp eq i64 %r_arg.fca.0.extract, 5       ; [#uses = 1]
  br i1 %43, label %case1, label %assertPassed

bounds.fail125:                                   ; preds = %endif121
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1721, i64 2, i64 %.len122.pre) #6
  unreachable

bounds.fail113:                                   ; preds = %endif109
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1720, i64 3, i64 %.len110) #6
  unreachable

bounds.fail101:                                   ; preds = %endif97
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1719, i64 2, i64 %.len98.pre) #6
  unreachable

bounds.fail89:                                    ; preds = %endif85
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1718, i64 3, i64 %.len86.pre) #6
  unreachable

assertPassed:                                     ; preds = %bounds.ok137
  %44 = add i64 %r_arg.fca.0.extract, -6          ; [#uses = 1]
  br label %forcond

forcond:                                          ; preds = %forinc, %assertPassed
  %.len153 = phi i64 [ %r_arg.fca.0.extract, %assertPassed ], [ %.len153.pre, %forinc ] ; [#uses = 5, type = i64]
  %i.0 = phi i64 [ %44, %assertPassed ], [ %61, %forinc ] ; [#uses = 6, type = i64]
  %45 = add nuw i64 %i.0, 1                       ; [#uses = 4]
  %bounds.cmp154 = icmp ult i64 %i.0, %.len153    ; [#uses = 1]
  br i1 %bounds.cmp154, label %bounds.ok155, label %bounds.fail156

bounds.ok155:                                     ; preds = %forcond
  %.ptr157 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 3]
  %46 = getelementptr inbounds i8, i8* %.ptr157, i64 %i.0 ; [#uses = 1, type = i8*]
  %47 = load i8, i8* %46, align 1                 ; [#uses = 3]
  %bounds.cmp159 = icmp ult i64 %45, %.len153     ; [#uses = 1]
  br i1 %bounds.cmp159, label %bounds.ok160, label %bounds.fail161

bounds.ok160:                                     ; preds = %bounds.ok155
  %48 = getelementptr inbounds i8, i8* %.ptr157, i64 %45 ; [#uses = 1, type = i8*]
  %49 = load i8, i8* %48, align 1                 ; [#uses = 2]
  %50 = icmp ugt i8 %49, %47                      ; [#uses = 1]
  br i1 %50, label %dowhile, label %endif164

dowhile:                                          ; preds = %bounds.ok160, %bounds.ok178
  %51 = phi i8 [ %57, %bounds.ok178 ], [ %49, %bounds.ok160 ] ; [#uses = 1, type = i8]
  %.ptr169 = phi i8* [ %.ptr180, %bounds.ok178 ], [ %.ptr157, %bounds.ok160 ] ; [#uses = 1, type = i8*]
  %.len165 = phi i64 [ %.len175, %bounds.ok178 ], [ %.len153, %bounds.ok160 ] ; [#uses = 4, type = i64]
  %j.0 = phi i64 [ %54, %bounds.ok178 ], [ %45, %bounds.ok160 ] ; [#uses = 7, type = i64]
  %bounds.cmp166 = icmp ult i64 %j.0, %.len165    ; [#uses = 1]
  br i1 %bounds.cmp166, label %bounds.ok167, label %bounds.fail168

bounds.ok167:                                     ; preds = %dowhile
  %52 = add i64 %j.0, -1                          ; [#uses = 3]
  %bounds.cmp171 = icmp ult i64 %52, %.len165     ; [#uses = 1]
  br i1 %bounds.cmp171, label %bounds.ok172, label %bounds.fail173

bounds.ok172:                                     ; preds = %bounds.ok167
  %53 = getelementptr inbounds i8, i8* %.ptr169, i64 %52 ; [#uses = 1, type = i8*]
  store i8 %51, i8* %53, align 1
  %54 = add nuw i64 %j.0, 1                       ; [#uses = 3]
  %.len175 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %55 = icmp ult i64 %54, %.len175                ; [#uses = 1]
  br i1 %55, label %bounds.ok178, label %enddowhile

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.11, i32 0, i32 0) }, i32 1753, i64 %52, i64 %.len165) #6
  unreachable

bounds.fail168:                                   ; preds = %dowhile
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1753, i64 %j.0, i64 %.len165) #6
  unreachable

bounds.ok178:                                     ; preds = %bounds.ok172
  %.ptr180 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %56 = getelementptr inbounds i8, i8* %.ptr180, i64 %54 ; [#uses = 1, type = i8*]
  %57 = load i8, i8* %56, align 1                 ; [#uses = 2]
  %58 = icmp ugt i8 %57, %47                      ; [#uses = 1]
  br i1 %58, label %dowhile, label %enddowhile

enddowhile:                                       ; preds = %bounds.ok172, %bounds.ok178
  %bounds.cmp182 = icmp ult i64 %j.0, %.len175    ; [#uses = 1]
  br i1 %bounds.cmp182, label %bounds.ok183, label %bounds.fail184

bounds.ok183:                                     ; preds = %enddowhile
  %.ptr185 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 1]
  %59 = getelementptr inbounds i8, i8* %.ptr185, i64 %j.0 ; [#uses = 1, type = i8*]
  store i8 %47, i8* %59, align 1
  br label %endif164

bounds.fail184:                                   ; preds = %enddowhile
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1761, i64 %j.0, i64 %.len175) #6
  unreachable

endif164:                                         ; preds = %bounds.ok183, %bounds.ok160
  %60 = icmp eq i64 %i.0, 0                       ; [#uses = 1]
  br i1 %60, 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.11, i32 0, i32 0) }, i32 1748, i64 %45, i64 %.len153) #6
  unreachable

bounds.fail156:                                   ; preds = %forcond
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1744, i64 %i.0, i64 %.len153) #6
  unreachable

forinc:                                           ; preds = %endif164
  %61 = add i64 %i.0, -1                          ; [#uses = 1]
  %.len153.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 1]
  br label %forcond
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T9buildHeapZQlFNaNbNiNfQBcZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 2]
  %1 = lshr i64 %r_arg.fca.0.extract, 1           ; [#uses = 1]
  br label %forcond

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

forbody:                                          ; preds = %forcond
  tail call void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T8siftDownZQkFNaNbNiNfQBbmymZv(i64 %r_arg.fca.0.extract, i64 %2, { i64, i8* } %r_arg) #2
  br label %forcond

endfor:                                           ; preds = %forcond
  %3 = tail call zeroext i1 @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T6isHeapZQiFNaNbNiNfQzZb({ i64, i8* } %r_arg) #2 ; [#uses = 1]
  br i1 %3, label %assertPassed, label %assertFailed

assertPassed:                                     ; preds = %endfor
  ret void

assertFailed:                                     ; preds = %endfor
  tail call void @_d_assert_msg({ i64, i8* } { i64 15, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.15, i32 0, i32 0) }, { i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2239) #6
  unreachable
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T7HeapOpsSQBi10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZ__T9percolateZQlFNaNbNiNfQBcmymZv(i64 %end_arg, i64 %parent_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 5, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 1]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 1]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 3, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  br label %forcond

forcond:                                          ; preds = %bounds.ok5, %0
  %parent.0 = phi i64 [ %parent_arg, %0 ], [ %spec.select, %bounds.ok5 ] ; [#uses = 4, type = i64]
  %1 = shl i64 %parent.0, 1                       ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 6]
  %.not = icmp ult i64 %2, %end_arg               ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %forcond
  %3 = icmp eq i64 %2, %end_arg                   ; [#uses = 1]
  br i1 %3, label %if1, label %forcond11.preheader

if1:                                              ; preds = %if
  %4 = or i64 %1, 1                               ; [#uses = 2]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %4, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond11.preheader

forcond11.preheader:                              ; preds = %if, %if1
  %child10.0.ph = phi i64 [ %parent.0, %if ], [ %4, %if1 ] ; [#uses = 1, type = i64]
  br label %forcond11

endif:                                            ; preds = %forcond
  %5 = or i64 %1, 1                               ; [#uses = 4]
  %.len = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp = icmp ult i64 %2, %.len            ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %endif
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp4 = icmp ult i64 %5, %.len           ; [#uses = 1]
  br i1 %bounds.cmp4, label %bounds.ok5, label %bounds.fail6

bounds.ok5:                                       ; preds = %bounds.ok
  %6 = getelementptr inbounds i8, i8* %.ptr, i64 %2 ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds i8, i8* %.ptr, i64 %5 ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %10 = icmp ugt i8 %8, %9                        ; [#uses = 1]
  %spec.select = select i1 %10, i64 %5, i64 %2    ; [#uses = 2]
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %spec.select, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond

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

bounds.fail:                                      ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2307, i64 %2, i64 %.len) #6
  unreachable

forcond11:                                        ; preds = %forcond11.preheader, %endif26
  %child10.0 = phi i64 [ %13, %endif26 ], [ %child10.0.ph, %forcond11.preheader ] ; [#uses = 6, type = i64]
  %11 = icmp ugt i64 %child10.0, %parent_arg      ; [#uses = 1]
  br i1 %11, label %forbody12, label %endfor14

forbody12:                                        ; preds = %forcond11
  %12 = add i64 %child10.0, -1                    ; [#uses = 1]
  %13 = lshr i64 %12, 1                           ; [#uses = 5]
  %.len15 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp16 = icmp ult i64 %13, %.len15       ; [#uses = 1]
  br i1 %bounds.cmp16, label %bounds.ok17, label %bounds.fail18

bounds.ok17:                                      ; preds = %forbody12
  %.ptr19 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp21 = icmp ult i64 %child10.0, %.len15 ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

bounds.ok22:                                      ; preds = %bounds.ok17
  %14 = getelementptr inbounds i8, i8* %.ptr19, i64 %13 ; [#uses = 1, type = i8*]
  %15 = getelementptr inbounds i8, i8* %.ptr19, i64 %child10.0 ; [#uses = 1, type = i8*]
  %16 = load i8, i8* %14, align 1                 ; [#uses = 1]
  %17 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %18 = icmp ugt i8 %16, %17                      ; [#uses = 1]
  br i1 %18, label %endif26, label %endfor14

endif26:                                          ; preds = %bounds.ok22
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %child10.0, i64 %13, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond11

bounds.fail23:                                    ; preds = %bounds.ok17
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2316, i64 %child10.0, i64 %.len15) #6
  unreachable

bounds.fail18:                                    ; preds = %forbody12
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2316, i64 %13, i64 %.len15) #6
  unreachable

endfor14:                                         ; preds = %bounds.ok22, %forcond11
  ret void
}

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

forcond:                                          ; preds = %endif31, %0
  %parent.0 = phi i64 [ %parent_arg, %0 ], [ %spec.select, %endif31 ] ; [#uses = 9, type = i64]
  %1 = shl i64 %parent.0, 1                       ; [#uses = 3]
  %2 = add i64 %1, 2                              ; [#uses = 6]
  %.not = icmp ult i64 %2, %end_arg               ; [#uses = 1]
  br i1 %.not, label %endif, label %if

if:                                               ; preds = %forcond
  %3 = icmp eq i64 %2, %end_arg                   ; [#uses = 1]
  br i1 %3, label %andand, label %endfor

andand:                                           ; preds = %if
  %.len = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp = icmp ult i64 %parent.0, %.len     ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %andand
  %.ptr = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %4 = or i64 %1, 1                               ; [#uses = 4]
  %bounds.cmp2 = icmp ult i64 %4, %.len           ; [#uses = 1]
  br i1 %bounds.cmp2, label %bounds.ok3, label %bounds.fail4

bounds.ok3:                                       ; preds = %bounds.ok
  %5 = getelementptr inbounds i8, i8* %.ptr, i64 %parent.0 ; [#uses = 1, type = i8*]
  %6 = getelementptr inbounds i8, i8* %.ptr, i64 %4 ; [#uses = 1, type = i8*]
  %7 = load i8, i8* %5, align 1                   ; [#uses = 1]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = icmp ugt i8 %7, %8                         ; [#uses = 1]
  br i1 %9, label %if6, label %endfor

bounds.fail4:                                     ; preds = %bounds.ok
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2265, i64 %4, i64 %.len) #6
  unreachable

bounds.fail:                                      ; preds = %andand
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2265, i64 %parent.0, i64 %.len) #6
  unreachable

if6:                                              ; preds = %bounds.ok3
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %4, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endfor

endif:                                            ; preds = %forcond
  %10 = or i64 %1, 1                              ; [#uses = 4]
  %.len8 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 8]
  %bounds.cmp9 = icmp ult i64 %2, %.len8          ; [#uses = 1]
  br i1 %bounds.cmp9, label %bounds.ok10, label %bounds.fail11

bounds.ok10:                                      ; preds = %endif
  %.ptr12 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 4]
  %bounds.cmp14 = icmp ult i64 %10, %.len8        ; [#uses = 1]
  br i1 %bounds.cmp14, label %bounds.ok15, label %bounds.fail16

bounds.ok15:                                      ; preds = %bounds.ok10
  %11 = getelementptr inbounds i8, i8* %.ptr12, i64 %2 ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr12, i64 %10 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ugt i8 %13, %14                      ; [#uses = 1]
  %spec.select = select i1 %15, i64 %10, i64 %2   ; [#uses = 5]
  %bounds.cmp21 = icmp ult i64 %parent.0, %.len8  ; [#uses = 1]
  br i1 %bounds.cmp21, label %bounds.ok22, label %bounds.fail23

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

bounds.ok27:                                      ; preds = %bounds.ok22
  %16 = getelementptr inbounds i8, i8* %.ptr12, i64 %parent.0 ; [#uses = 1, type = i8*]
  %17 = getelementptr inbounds i8, i8* %.ptr12, i64 %spec.select ; [#uses = 1, type = i8*]
  %18 = load i8, i8* %16, align 1                 ; [#uses = 1]
  %19 = load i8, i8* %17, align 1                 ; [#uses = 1]
  %20 = icmp ugt i8 %18, %19                      ; [#uses = 1]
  br i1 %20, label %endif31, label %endfor

endif31:                                          ; preds = %bounds.ok27
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %spec.select, i64 %parent.0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %forcond

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

bounds.fail23:                                    ; preds = %bounds.ok15
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2271, i64 %parent.0, i64 %.len8) #6
  unreachable

bounds.fail16:                                    ; preds = %bounds.ok10
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2270, i64 %10, i64 %.len8) #6
  unreachable

bounds.fail11:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 2270, i64 %2, i64 %.len8) #6
  unreachable

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

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

forcond:                                          ; preds = %endif, %0
  %__key396.0 = phi i64 [ 1, %0 ], [ %10, %endif ] ; [#uses = 4, type = i64]
  %parent.0 = phi i64 [ 0, %0 ], [ %9, %endif ]   ; [#uses = 4, type = i64]
  %exitcond.not = icmp eq i64 %__key396.0, %umax  ; [#uses = 1]
  br i1 %exitcond.not, label %if, label %forbody

forbody:                                          ; preds = %forcond
  %bounds.cmp = icmp ult i64 %parent.0, %r_arg.fca.0.extract ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok4, label %bounds.fail

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

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

endif:                                            ; preds = %bounds.ok4
  %7 = and i64 %__key396.0, 1                     ; [#uses = 1]
  %8 = xor i64 %7, 1                              ; [#uses = 1]
  %9 = add i64 %8, %parent.0                      ; [#uses = 1]
  %10 = add i64 %__key396.0, 1                    ; [#uses = 1]
  br label %forcond

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmZQFeFNaNbNiNfQvmmmZv(i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 8, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 9]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 3, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 5]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 3, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %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 i8, i8* %r_arg.fca.1.extract, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %4 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %5 = load i8, i8* %3, align 1                   ; [#uses = 2]
  %6 = load i8, i8* %4, align 1                   ; [#uses = 3]
  %7 = icmp ugt i8 %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 i8, i8* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %9 = load i8, i8* %8, align 1                   ; [#uses = 1]
  %10 = icmp ugt i8 %6, %9                        ; [#uses = 1]
  br i1 %10, label %if21, label %else23

if21:                                             ; preds = %bounds.ok18
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

else23:                                           ; preds = %bounds.ok18
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len24 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 4]
  %bounds.cmp25 = icmp ugt i64 %.len24, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp25, label %bounds.ok26, label %bounds.fail27

bounds.ok26:                                      ; preds = %else23
  %.ptr28 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %bounds.cmp30 = icmp ugt i64 %.len24, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp30, label %bounds.ok31, label %bounds.fail32

bounds.ok31:                                      ; preds = %bounds.ok26
  %11 = getelementptr inbounds i8, i8* %.ptr28, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr28, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ugt i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %if34, label %endif

if34:                                             ; preds = %bounds.ok31
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

bounds.fail32:                                    ; preds = %bounds.ok26
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4280, i64 %_param_1_arg, i64 %.len24) #6
  unreachable

bounds.fail27:                                    ; preds = %else23
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4280, i64 %_param_2_arg, i64 %.len24) #6
  unreachable

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.11, i32 0, i32 0) }, i32 4272, i64 %_param_2_arg, i64 %r_arg.fca.0.extract) #6
  unreachable

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

bounds.ok43:                                      ; preds = %else
  %16 = getelementptr inbounds i8, i8* %r_arg.fca.1.extract, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %16, align 1                 ; [#uses = 2]
  %18 = icmp ugt i8 %17, %6                       ; [#uses = 1]
  br i1 %18, label %if46, label %bounds.ok56

if46:                                             ; preds = %bounds.ok43
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

bounds.ok56:                                      ; preds = %bounds.ok43
  %19 = icmp ugt i8 %5, %17                       ; [#uses = 1]
  br i1 %19, label %if59, label %endif

if59:                                             ; preds = %bounds.ok56
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif

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

endif:                                            ; preds = %if46, %if59, %bounds.ok56, %if21, %if34, %bounds.ok31
  %.len61 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp62 = icmp ugt i64 %.len61, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp62, label %bounds.ok63, label %bounds.fail64

bounds.ok63:                                      ; preds = %endif
  %.ptr65 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 3]
  %bounds.cmp67 = icmp ugt i64 %.len61, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %bounds.ok63
  %20 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %21 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %22 = load i8, i8* %20, align 1                 ; [#uses = 2]
  %23 = load i8, i8* %21, align 1                 ; [#uses = 1]
  %24 = icmp ugt i8 %22, %23                      ; [#uses = 1]
  br i1 %24, label %assertFailed72, label %assertPassed71

assertPassed71:                                   ; preds = %bounds.ok68
  %bounds.cmp74 = icmp ugt i64 %.len61, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp74, label %bounds.ok80, label %bounds.fail76

bounds.ok80:                                      ; preds = %assertPassed71
  %25 = getelementptr inbounds i8, i8* %.ptr65, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %26 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %27 = icmp ugt i8 %26, %22                      ; [#uses = 1]
  br i1 %27, label %assertFailed84, label %assertPassed83

assertPassed83:                                   ; preds = %bounds.ok80
  ret void

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

bounds.fail76:                                    ; preds = %assertPassed71
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4295, i64 %_param_3_arg, i64 %.len61) #6
  unreachable

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

bounds.fail69:                                    ; preds = %bounds.ok63
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4294, i64 %_param_1_arg, i64 %.len61) #6
  unreachable

bounds.fail64:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4294, i64 %_param_2_arg, i64 %.len61) #6
  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.11, i32 0, i32 0) }, i32 4270, i64 %_param_1_arg, i64 %r_arg.fca.0.extract) #6
  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.11, i32 0, i32 0) }, i32 4270, i64 %_param_3_arg, i64 %r_arg.fca.0.extract) #6
  unreachable

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T8medianOfSQBj10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoVEQDu8typecons__T4FlagVQCda9_6c65616e5269676874ZQBfi0TAhTmTmTmTmTmZQFiFNaNbNiNfQzmmmmmZv(i64 %_param_5_arg, i64 %_param_4_arg, i64 %_param_3_arg, i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* byval align 8 %r) local_unnamed_addr #1 {
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 6, type = i64*]
  %.len = load i64, i64* %1, align 8              ; [#uses = 6]
  %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, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 6, type = i8**]
  %.ptr = load i8*, i8** %9, align 8              ; [#uses = 2]
  %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 i8, i8* %.ptr, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %11 = getelementptr inbounds i8, i8* %.ptr, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %12 = load i8, i8* %10, align 1                 ; [#uses = 1]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = icmp ugt i8 %12, %13                      ; [#uses = 1]
  br i1 %14, label %if, label %endif

if:                                               ; preds = %bounds.ok27
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len30.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif

endif:                                            ; preds = %if, %bounds.ok27
  %.len30 = phi i64 [ %.len30.pre, %if ], [ %.len, %bounds.ok27 ] ; [#uses = 5, type = i64]
  %bounds.cmp31 = icmp ugt i64 %.len30, %_param_4_arg ; [#uses = 1]
  br i1 %bounds.cmp31, label %bounds.ok32, label %bounds.fail33

bounds.ok32:                                      ; preds = %endif
  %.ptr34 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp36 = icmp ugt i64 %.len30, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp36, label %bounds.ok37, label %bounds.fail38

bounds.ok37:                                      ; preds = %bounds.ok32
  %15 = getelementptr inbounds i8, i8* %.ptr34, i64 %_param_4_arg ; [#uses = 1, type = i8*]
  %16 = getelementptr inbounds i8, i8* %.ptr34, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %15, align 1                 ; [#uses = 1]
  %18 = load i8, i8* %16, align 1                 ; [#uses = 1]
  %19 = icmp ugt i8 %17, %18                      ; [#uses = 1]
  br i1 %19, label %if40, label %endif41

if40:                                             ; preds = %bounds.ok37
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_4_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len42.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif41

endif41:                                          ; preds = %if40, %bounds.ok37
  %.len42 = phi i64 [ %.len42.pre, %if40 ], [ %.len30, %bounds.ok37 ] ; [#uses = 5, type = i64]
  %bounds.cmp43 = icmp ugt i64 %.len42, %_param_4_arg ; [#uses = 1]
  br i1 %bounds.cmp43, label %bounds.ok44, label %bounds.fail45

bounds.ok44:                                      ; preds = %endif41
  %.ptr46 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp48 = icmp ugt i64 %.len42, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp48, label %bounds.ok49, label %bounds.fail50

bounds.ok49:                                      ; preds = %bounds.ok44
  %20 = getelementptr inbounds i8, i8* %.ptr46, i64 %_param_4_arg ; [#uses = 1, type = i8*]
  %21 = getelementptr inbounds i8, i8* %.ptr46, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %22 = load i8, i8* %20, align 1                 ; [#uses = 1]
  %23 = load i8, i8* %21, align 1                 ; [#uses = 1]
  %24 = icmp ugt i8 %22, %23                      ; [#uses = 1]
  br i1 %24, label %if52, label %endif53

if52:                                             ; preds = %bounds.ok49
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_4_arg, i64 %_param_3_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_2_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len54.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif53

endif53:                                          ; preds = %if52, %bounds.ok49
  %.len54 = phi i64 [ %.len54.pre, %if52 ], [ %.len42, %bounds.ok49 ] ; [#uses = 5, type = i64]
  %bounds.cmp55 = icmp ugt i64 %.len54, %_param_5_arg ; [#uses = 1]
  br i1 %bounds.cmp55, label %bounds.ok56, label %bounds.fail57

bounds.ok56:                                      ; preds = %endif53
  %.ptr58 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp60 = icmp ugt i64 %.len54, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp60, label %bounds.ok61, label %bounds.fail62

bounds.ok61:                                      ; preds = %bounds.ok56
  %25 = getelementptr inbounds i8, i8* %.ptr58, i64 %_param_5_arg ; [#uses = 1, type = i8*]
  %26 = getelementptr inbounds i8, i8* %.ptr58, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %27 = load i8, i8* %25, align 1                 ; [#uses = 1]
  %28 = load i8, i8* %26, align 1                 ; [#uses = 1]
  %29 = icmp ugt i8 %27, %28                      ; [#uses = 1]
  br i1 %29, label %if64, label %endif65

if64:                                             ; preds = %bounds.ok61
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_5_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len66.pre = load i64, i64* %1, align 8        ; [#uses = 1]
  br label %endif65

endif65:                                          ; preds = %if64, %bounds.ok61
  %.len66 = phi i64 [ %.len66.pre, %if64 ], [ %.len54, %bounds.ok61 ] ; [#uses = 6, type = i64]
  %bounds.cmp67 = icmp ugt i64 %.len66, %_param_5_arg ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %endif65
  %.ptr70 = load i8*, i8** %9, align 8            ; [#uses = 3]
  %bounds.cmp72 = icmp ugt i64 %.len66, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp72, label %bounds.ok73, label %bounds.fail74

bounds.ok73:                                      ; preds = %bounds.ok68
  %30 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_5_arg ; [#uses = 1, type = i8*]
  %31 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %32 = load i8, i8* %30, align 1                 ; [#uses = 1]
  %33 = load i8, i8* %31, align 1                 ; [#uses = 2]
  %34 = icmp ugt i8 %32, %33                      ; [#uses = 1]
  br i1 %34, label %if76, label %bounds.ok92

if76:                                             ; preds = %bounds.ok73
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_5_arg, i64 %_param_3_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len78 = load i64, i64* %1, align 8            ; [#uses = 4]
  %bounds.cmp79 = icmp ugt i64 %.len78, %_param_3_arg ; [#uses = 1]
  br i1 %bounds.cmp79, label %bounds.ok80, label %bounds.fail81

bounds.ok80:                                      ; preds = %if76
  %.ptr82 = load i8*, i8** %9, align 8            ; [#uses = 2]
  %bounds.cmp84 = icmp ugt i64 %.len78, %_param_1_arg ; [#uses = 1]
  br i1 %bounds.cmp84, label %bounds.ok85, label %bounds.fail86

bounds.ok85:                                      ; preds = %bounds.ok80
  %35 = getelementptr inbounds i8, i8* %.ptr82, i64 %_param_3_arg ; [#uses = 1, type = i8*]
  %36 = getelementptr inbounds i8, i8* %.ptr82, i64 %_param_1_arg ; [#uses = 1, type = i8*]
  %37 = load i8, i8* %35, align 1                 ; [#uses = 1]
  %38 = load i8, i8* %36, align 1                 ; [#uses = 1]
  %39 = icmp ugt i8 %37, %38                      ; [#uses = 1]
  br i1 %39, label %if88, label %endif77

if88:                                             ; preds = %bounds.ok85
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_1_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail86:                                    ; preds = %bounds.ok80
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4336, i64 %_param_1_arg, i64 %.len78) #6
  unreachable

bounds.fail81:                                    ; preds = %if76
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4336, i64 %_param_3_arg, i64 %.len78) #6
  unreachable

bounds.ok92:                                      ; preds = %bounds.ok73
  %bounds.cmp96 = icmp ugt i64 %.len66, %_param_2_arg ; [#uses = 1]
  br i1 %bounds.cmp96, label %bounds.ok97, label %bounds.fail98

bounds.ok97:                                      ; preds = %bounds.ok92
  %40 = getelementptr inbounds i8, i8* %.ptr70, i64 %_param_2_arg ; [#uses = 1, type = i8*]
  %41 = load i8, i8* %40, align 1                 ; [#uses = 1]
  %42 = icmp ugt i8 %33, %41                      ; [#uses = 1]
  br i1 %42, label %if100, label %endif77

if100:                                            ; preds = %bounds.ok97
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 %_param_3_arg, i64 %_param_2_arg, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail98:                                    ; preds = %bounds.ok92
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4340, i64 %_param_2_arg, i64 %.len66) #6
  unreachable

endif77:                                          ; preds = %bounds.ok97, %if100, %bounds.ok85, %if88
  ret void

bounds.fail74:                                    ; preds = %bounds.ok68
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4333, i64 %_param_3_arg, i64 %.len66) #6
  unreachable

bounds.fail69:                                    ; preds = %endif65
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4333, i64 %_param_5_arg, i64 %.len66) #6
  unreachable

bounds.fail62:                                    ; preds = %bounds.ok56
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4332, i64 %_param_2_arg, i64 %.len54) #6
  unreachable

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

bounds.fail50:                                    ; preds = %bounds.ok44
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4327, i64 %_param_3_arg, i64 %.len42) #6
  unreachable

bounds.fail45:                                    ; preds = %endif41
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4327, i64 %_param_4_arg, i64 %.len42) #6
  unreachable

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

bounds.fail33:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 4326, i64 %_param_4_arg, i64 %.len30) #6
  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.11, i32 0, i32 0) }, i32 4325, i64 %_param_1_arg, i64 %.len) #6
  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.11, i32 0, i32 0) }, i32 4325, i64 %_param_3_arg, i64 %.len) #6
  unreachable

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

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

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm7sorting__T5sort5SQBg10functional__T9binaryFunVAyaa3_613e62VQna1_61VQva1_62ZQBoTAhZQCuFNaNbNiNfQpZv({ i64, i8* } %r_arg) local_unnamed_addr #1 {
  %r = alloca { i64, i8* }, align 8               ; [#uses = 13, size/byte = 16]
  %r_arg.fca.0.extract = extractvalue { i64, i8* } %r_arg, 0 ; [#uses = 3]
  %r_arg.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 0 ; [#uses = 7, type = i64*]
  store i64 %r_arg.fca.0.extract, i64* %r_arg.fca.0.gep, align 8
  %r_arg.fca.1.extract = extractvalue { i64, i8* } %r_arg, 1 ; [#uses = 3]
  %r_arg.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %r, i64 0, i32 1 ; [#uses = 7, type = i8**]
  store i8* %r_arg.fca.1.extract, i8** %r_arg.fca.1.gep, align 8
  %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 i8, i8* %r_arg.fca.1.extract, i64 1 ; [#uses = 1, type = i8*]
  %3 = load i8, i8* %2, align 1                   ; [#uses = 1]
  %4 = load i8, i8* %r_arg.fca.1.extract, align 1 ; [#uses = 1]
  %5 = icmp ugt i8 %3, %4                         ; [#uses = 1]
  br i1 %5, label %endif, label %bounds.ok9

endif:                                            ; preds = %bounds.ok4
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len7.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp8 = icmp ugt i64 %.len7.pre, 3       ; [#uses = 1]
  br i1 %bounds.cmp8, label %bounds.ok9, label %bounds.fail10

bounds.ok9:                                       ; preds = %bounds.ok4, %endif
  %.len7196 = phi i64 [ %.len7.pre, %endif ], [ %r_arg.fca.0.extract, %bounds.ok4 ] ; [#uses = 1, type = i64]
  %.ptr11 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %6 = getelementptr inbounds i8, i8* %.ptr11, i64 3 ; [#uses = 1, type = i8*]
  %7 = getelementptr inbounds i8, i8* %.ptr11, i64 2 ; [#uses = 1, type = i8*]
  %8 = load i8, i8* %6, align 1                   ; [#uses = 1]
  %9 = load i8, i8* %7, align 1                   ; [#uses = 1]
  %10 = icmp ugt i8 %8, %9                        ; [#uses = 1]
  br i1 %10, label %endif18, label %bounds.ok21

endif18:                                          ; preds = %bounds.ok9
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len19.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp20 = icmp ugt i64 %.len19.pre, 3     ; [#uses = 1]
  br i1 %bounds.cmp20, label %bounds.ok21, label %bounds.fail22

bounds.ok21:                                      ; preds = %bounds.ok9, %endif18
  %.len19199 = phi i64 [ %.len19.pre, %endif18 ], [ %.len7196, %bounds.ok9 ] ; [#uses = 1, type = i64]
  %.ptr23 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %11 = getelementptr inbounds i8, i8* %.ptr23, i64 3 ; [#uses = 1, type = i8*]
  %12 = getelementptr inbounds i8, i8* %.ptr23, i64 1 ; [#uses = 1, type = i8*]
  %13 = load i8, i8* %11, align 1                 ; [#uses = 1]
  %14 = load i8, i8* %12, align 1                 ; [#uses = 1]
  %15 = icmp ugt i8 %13, %14                      ; [#uses = 1]
  br i1 %15, label %endif30, label %bounds.ok33

endif30:                                          ; preds = %bounds.ok21
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len31.pre = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 3]
  %bounds.cmp32 = icmp ugt i64 %.len31.pre, 1     ; [#uses = 1]
  br i1 %bounds.cmp32, label %bounds.ok33, label %bounds.fail34

bounds.ok33:                                      ; preds = %bounds.ok21, %endif30
  %.len31202 = phi i64 [ %.len31.pre, %endif30 ], [ %.len19199, %bounds.ok21 ] ; [#uses = 4, type = i64]
  %.ptr35 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 5]
  %16 = getelementptr inbounds i8, i8* %.ptr35, i64 1 ; [#uses = 1, type = i8*]
  %17 = load i8, i8* %16, align 1                 ; [#uses = 3]
  %18 = load i8, i8* %.ptr35, align 1             ; [#uses = 1]
  %19 = icmp ugt i8 %17, %18                      ; [#uses = 1]
  br i1 %19, label %assertFailed65, label %andand

andand:                                           ; preds = %bounds.ok33
  %bounds.cmp42 = icmp ugt i64 %.len31202, 3      ; [#uses = 1]
  br i1 %bounds.cmp42, label %bounds.ok43, label %bounds.fail44

bounds.ok43:                                      ; preds = %andand
  %20 = getelementptr inbounds i8, i8* %.ptr35, i64 3 ; [#uses = 1, type = i8*]
  %21 = load i8, i8* %20, align 1                 ; [#uses = 3]
  %22 = icmp ugt i8 %21, %17                      ; [#uses = 1]
  br i1 %22, label %assertFailed65, label %bounds.ok55

bounds.fail44:                                    ; preds = %andand
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1821, i64 3, i64 %.len31202) #6
  unreachable

bounds.ok55:                                      ; preds = %bounds.ok43
  %23 = getelementptr inbounds i8, i8* %.ptr35, i64 2 ; [#uses = 1, type = i8*]
  %24 = load i8, i8* %23, align 1                 ; [#uses = 1]
  %25 = icmp ugt i8 %21, %24                      ; [#uses = 1]
  br i1 %25, label %assertFailed65, label %assertPassed64

assertPassed64:                                   ; preds = %bounds.ok55
  %bounds.cmp67 = icmp ugt i64 %.len31202, 4      ; [#uses = 1]
  br i1 %bounds.cmp67, label %bounds.ok68, label %bounds.fail69

bounds.ok68:                                      ; preds = %assertPassed64
  %26 = getelementptr inbounds i8, i8* %.ptr35, i64 4 ; [#uses = 1, type = i8*]
  %27 = load i8, i8* %26, align 1                 ; [#uses = 2]
  %28 = icmp ugt i8 %27, %17                      ; [#uses = 1]
  br i1 %28, label %if76, label %bounds.ok92

if76:                                             ; preds = %bounds.ok68
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 4, i64 3, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len78 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp79 = icmp ugt i64 %.len78, 1         ; [#uses = 1]
  br i1 %bounds.cmp79, label %bounds.ok80, label %bounds.fail81

bounds.ok80:                                      ; preds = %if76
  %.ptr82 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %29 = getelementptr inbounds i8, i8* %.ptr82, i64 1 ; [#uses = 1, type = i8*]
  %30 = load i8, i8* %29, align 1                 ; [#uses = 1]
  %31 = load i8, i8* %.ptr82, align 1             ; [#uses = 1]
  %32 = icmp ugt i8 %30, %31                      ; [#uses = 1]
  br i1 %32, label %if88, label %endif77

if88:                                             ; preds = %bounds.ok80
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

bounds.fail81:                                    ; preds = %if76
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1829, i64 1, i64 %.len78) #6
  unreachable

bounds.ok92:                                      ; preds = %bounds.ok68
  %33 = icmp ugt i8 %27, %21                      ; [#uses = 1]
  br i1 %33, label %if100, label %endif77

if100:                                            ; preds = %bounds.ok92
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 4, i64 3, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif77

endif77:                                          ; preds = %bounds.ok92, %if100, %bounds.ok80, %if88
  %.len102 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 6]
  %bounds.cmp103 = icmp ugt i64 %.len102, 1       ; [#uses = 1]
  br i1 %bounds.cmp103, label %bounds.ok104, label %bounds.fail105

bounds.ok104:                                     ; preds = %endif77
  %.ptr106 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 5]
  %34 = getelementptr inbounds i8, i8* %.ptr106, i64 1 ; [#uses = 1, type = i8*]
  %35 = load i8, i8* %34, align 1                 ; [#uses = 3]
  %36 = load i8, i8* %.ptr106, align 1            ; [#uses = 1]
  %37 = icmp ugt i8 %35, %36                      ; [#uses = 1]
  br i1 %37, label %assertFailed139, label %andand112

andand112:                                        ; preds = %bounds.ok104
  %bounds.cmp115 = icmp ugt i64 %.len102, 3       ; [#uses = 1]
  br i1 %bounds.cmp115, label %bounds.ok116, label %bounds.fail117

bounds.ok116:                                     ; preds = %andand112
  %38 = getelementptr inbounds i8, i8* %.ptr106, i64 3 ; [#uses = 1, type = i8*]
  %39 = load i8, i8* %38, align 1                 ; [#uses = 3]
  %40 = icmp ugt i8 %39, %35                      ; [#uses = 1]
  br i1 %40, label %assertFailed139, label %andand125

bounds.fail117:                                   ; preds = %andand112
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 3, i64 %.len102) #6
  unreachable

andand125:                                        ; preds = %bounds.ok116
  %bounds.cmp128 = icmp ugt i64 %.len102, 4       ; [#uses = 1]
  br i1 %bounds.cmp128, label %bounds.ok129, label %bounds.fail130

bounds.ok129:                                     ; preds = %andand125
  %41 = getelementptr inbounds i8, i8* %.ptr106, i64 4 ; [#uses = 1, type = i8*]
  %42 = load i8, i8* %41, align 1                 ; [#uses = 2]
  %43 = icmp ugt i8 %42, %39                      ; [#uses = 1]
  br i1 %43, label %assertFailed139, label %bounds.ok142

bounds.fail130:                                   ; preds = %andand125
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 4, i64 %.len102) #6
  unreachable

bounds.ok142:                                     ; preds = %bounds.ok129
  %44 = getelementptr inbounds i8, i8* %.ptr106, i64 2 ; [#uses = 1, type = i8*]
  %45 = load i8, i8* %44, align 1                 ; [#uses = 3]
  %46 = icmp ugt i8 %42, %45                      ; [#uses = 1]
  br i1 %46, label %assertFailed151, label %bounds.ok154

bounds.ok154:                                     ; preds = %bounds.ok142
  %47 = icmp ugt i8 %45, %35                      ; [#uses = 1]
  br i1 %47, label %if162, label %bounds.ok179

if162:                                            ; preds = %bounds.ok154
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 2, i64 1, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  %.len165 = load i64, i64* %r_arg.fca.0.gep, align 8 ; [#uses = 2]
  %bounds.cmp166 = icmp ugt i64 %.len165, 1       ; [#uses = 1]
  br i1 %bounds.cmp166, label %bounds.ok167, label %bounds.fail168

bounds.ok167:                                     ; preds = %if162
  %.ptr169 = load i8*, i8** %r_arg.fca.1.gep, align 8 ; [#uses = 2]
  %48 = getelementptr inbounds i8, i8* %.ptr169, i64 1 ; [#uses = 1, type = i8*]
  %49 = load i8, i8* %48, align 1                 ; [#uses = 1]
  %50 = load i8, i8* %.ptr169, align 1            ; [#uses = 1]
  %51 = icmp ugt i8 %49, %50                      ; [#uses = 1]
  br i1 %51, label %if175, label %endif163

if175:                                            ; preds = %bounds.ok167
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 1, i64 0, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif163

bounds.fail168:                                   ; preds = %if162
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1846, i64 1, i64 %.len165) #6
  unreachable

bounds.ok179:                                     ; preds = %bounds.ok154
  %52 = icmp ugt i8 %39, %45                      ; [#uses = 1]
  br i1 %52, label %if187, label %endif163

if187:                                            ; preds = %bounds.ok179
  call void @_D3std9algorithm8mutation__T6swapAtTAhZQlFNaNbNiNfKQpmmZv(i64 3, i64 2, { i64, i8* }* nonnull dereferenceable(16) %r) #1
  br label %endif163

endif163:                                         ; preds = %bounds.ok179, %if187, %bounds.ok167, %if175
  ret void

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

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

bounds.fail105:                                   ; preds = %endif77
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1838, i64 1, i64 %.len102) #6
  unreachable

bounds.fail69:                                    ; preds = %assertPassed64
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1825, i64 4, i64 %.len31202) #6
  unreachable

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

bounds.fail34:                                    ; preds = %endif30
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1821, i64 1, i64 %.len31.pre) #6
  unreachable

bounds.fail22:                                    ; preds = %endif18
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1816, i64 3, i64 %.len19.pre) #6
  unreachable

bounds.fail10:                                    ; preds = %endif
  call void @_d_arraybounds_index({ i64, i8* } { i64 63, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i32 0, i32 0) }, i32 1813, i64 3, i64 %.len7.pre) #6
  unreachable

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

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

if:                                               ; preds = %condend
  ret i32 %0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr i32 @_D3std9exception__T7enforceHTCQBcQBb14ErrnoExceptionZ__TQBlTiZQBrFNfiLAxaAyamZi(i64 %line_arg, { i64, i8* } %file_arg, { i8*, { i64, i8* } (i8*)* } %msg_arg, i32 %value_arg) local_unnamed_addr #1 {
  %.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) #10
  unreachable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFNaQkKmZw(i64* dereferenceable(8) %index, { i64, i8* } %str_arg) local_unnamed_addr #1 {
  %.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) #1 ; [#uses = 1]
  %9 = bitcast %std.utf.UTFException* %8 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %9) #6
  unreachable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

endif41:                                          ; preds = %endif38
  ret i32 %72

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

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

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

; [#uses = 2]
; Function Attrs: uwtable
define weak_odr %std.utf.UTFException* @_D3std3utf__T10decodeImplVbi1VEQBd8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0TAxaZQDrFQiKmZ__T9exceptionTQBbZQpFNaNbNfQBoQDrZCQFuQFt12UTFException({ i64, i8* } %msg_arg, { i64, i8* } %str_arg) local_unnamed_addr #1 {
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.32, i32 0, i32 0) }, i32 1544, i64 %str_arg.fca.0.extract, i64 %str_arg.fca.0.extract) #6
  unreachable

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

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

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

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

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

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

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

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

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

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

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

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

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr i32 @_D3std3utf__T13_utfExceptionVEQBc8typecons__T4FlagVAyaa19_7573655265706c6163656d656e744463686172ZQCai0ZQDmFNaNfQCiwZw(i32 %c_arg, { i64, i8* } %msg_arg) local_unnamed_addr #1 {
  %.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.32, i32 0, i32 0) }, { i64, i8* }* nonnull byval align 8 %.lval_copy_for_ImplicitByvalRewrite) #2 ; [#uses = 0]
  %5 = load [11 x i8*]*, [11 x i8*]** %vtbl, align 8 ; [#uses = 1]
  %"setSequence@vtbl" = getelementptr inbounds [11 x i8*], [11 x i8*]* %5, i64 0, i64 10 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %"setSequence@vtbl" to %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** ; [#uses = 1]
  %7 = load %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })*, %std.utf.UTFException* (%std.utf.UTFException*, { i64, i32* })** %6, align 8 ; [#uses = 1]
  %8 = getelementptr inbounds [1 x i32], [1 x i32]* %arrayliteral, i64 0, i64 0 ; [#uses = 2, type = i32*]
  store i32 %c_arg, i32* %8, align 4
  %9 = insertvalue { i64, i32* } { i64 1, i32* undef }, i32* %8, 1 ; [#uses = 1]
  %10 = call %std.utf.UTFException* %7(%std.utf.UTFException* nonnull %.newclass_gc, { i64, i32* } %9) ; [#uses = 1]
  %11 = bitcast %std.utf.UTFException* %10 to %object.Throwable* ; [#uses = 1]
  call void @_d_throw_exception(%object.Throwable* %11) #6
  unreachable
}

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

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

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

; [#uses = 0]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm8mutation__T8moveImplTAhZQnFNaNbNiNfMNkKQsZQv({ i64, i8* }* dereferenceable(16) %source) local_unnamed_addr #1 {
  %1 = tail call { i64, i8* } @_D3std9algorithm8mutation__T15trustedMoveImplTAhZQvFNaNbNiNeMNkKQsZQv({ i64, i8* }* nonnull dereferenceable(16) %source) #2 ; [#uses = 1]
  ret { i64, i8* } %1
}

; [#uses = 4]
; Function Attrs: uwtable
define weak_odr { i64, i8* } @_D3std9algorithm8mutation__T15trustedMoveImplTAhZQvFNaNbNiNeMNkKQsZQv({ i64, i8* }* dereferenceable(16) %source) local_unnamed_addr #1 {
  %result = alloca { i64, i8* }, align 8          ; [#uses = 3, size/byte = 16]
  call void @_D3std9algorithm8mutation__T15moveEmplaceImplTAhZQvFNaNbNiNfMKQqMNkKQwZv({ i64, i8* }* nonnull dereferenceable(16) %source, { i64, i8* }* nonnull dereferenceable(16) %result) #1
  %.fca.0.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %result, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.fca.0.load = load i64, i64* %.fca.0.gep, align 8 ; [#uses = 1]
  %.fca.0.insert = insertvalue { i64, i8* } undef, i64 %.fca.0.load, 0 ; [#uses = 1]
  %.fca.1.gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %result, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %.fca.1.load = load i8*, i8** %.fca.1.gep, align 8 ; [#uses = 1]
  %.fca.1.insert6 = insertvalue { i64, i8* } %.fca.0.insert, i8* %.fca.1.load, 1 ; [#uses = 1]
  ret { i64, i8* } %.fca.1.insert6
}

; [#uses = 1]
; Function Attrs: uwtable
define weak_odr void @_D3std9algorithm8mutation__T15moveEmplaceImplTAhZQvFNaNbNiNfMKQqMNkKQwZv({ i64, i8* }* dereferenceable(16) %source, { i64, i8* }* dereferenceable(16) %target) local_unnamed_addr #1 {
andandend:
  %0 = tail call zeroext i1 @_D3std9exception__T11doesPointToTAhTQdTvZQwFNaNbNiNeKxAhKxQeZb({ i64, i8* }* nonnull dereferenceable(16) %source, { i64, i8* }* nonnull dereferenceable(16) %source) #1 ; [#uses = 1]
  br i1 %0, label %assertFailed, label %assertPassed

assertPassed:                                     ; preds = %andandend
  %1 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %2 = bitcast i8** %1 to i64*                    ; [#uses = 1]
  %.ptr1 = load i64, i64* %2, align 8             ; [#uses = 1]
  %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %source, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len = load i64, i64* %3, align 8              ; [#uses = 1]
  %4 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %target, i64 0, i32 0 ; [#uses = 1, type = i64*]
  store i64 %.len, i64* %4, align 8
  %5 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %target, i64 0, i32 1 ; [#uses = 1, type = i8**]
  %6 = bitcast i8** %5 to i64*                    ; [#uses = 1]
  store i64 %.ptr1, i64* %6, align 8
  ret void

assertFailed:                                     ; preds = %andandend
  tail call void @_d_assert_msg({ i64, i8* } { i64 72, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.36, i32 0, i32 0) }, { i64, i8* } { i64 64, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.16, i32 0, i32 0) }, i32 1429) #6
  unreachable
}

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

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

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

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

!llvm.ldc.typeinfo._D9Exception7__ClassZ = !{!0}
!llvm.ldc.classinfo._D9Exception7__ClassZ = !{!1}
!llvm.ldc.typeinfo._D12TypeInfo_xAh6__initZ = !{!2}
!llvm.ldc.typeinfo._D12TypeInfo_Axh6__initZ = !{!2}
!llvm.ldc.typeinfo._D11TypeInfo_xh6__initZ = !{!3}
!llvm.ldc.typeinfo._D10TypeInfo_h6__initZ = !{!3}
!llvm.ldc.typeinfo._D11TypeInfo_Ah6__initZ = !{!2}
!llvm.ldc.typeinfo._D3std9exception14ErrnoException7__ClassZ = !{!4}
!llvm.ldc.classinfo._D3std9exception14ErrnoException7__ClassZ = !{!5}
!llvm.ldc.typeinfo._D3std3utf12UTFException7__ClassZ = !{!6}
!llvm.ldc.classinfo._D3std3utf12UTFException7__ClassZ = !{!7}
!llvm.ident = !{!8}

!0 = !{%object.Exception* undef}
!1 = !{%object.Exception undef, i1 false}
!2 = !{{ i64, i8* } undef}
!3 = !{i8 undef}
!4 = !{%std.exception.ErrnoException* undef}
!5 = !{%std.exception.ErrnoException undef, i1 false}
!6 = !{%std.utf.UTFException* undef}
!7 = !{%std.utf.UTFException undef, i1 false}
!8 = !{!"ldc version 1.28.0"}
