import std.stdio;
import std.algorithm;
import core.stdc.stdio;

int[] ds;
int[] as;

int[][] dim2arr(int w,int h){
	int[] buf = new int[w*h];
	int[][] ret = new int[][h];
	for(int i=0;i<h;i++){
		ret[i] = buf[i*w..(i+1)*w];
	}
	return ret;
}

int factorial(int a){
	if(a <= 1)
		return 1;
	else
		return a * (a-1).factorial;
}

int unUsed(bool[] used,int idx){
	foreach(int i,ref b;used){
		if(!b){
			if(idx-- == 0){
				b = true;
				return i;
			}
		}
	}
	assert(false);
}

int dMax=0;

bool[] used;
void sequence(int[] dest,int t){
	used[] = false;
	for(int i=0;i<dMax;i++){
		dest[i] = used.unUsed(t % (dMax-i));
		t /= (dMax-i);
	}
}

int[] seqTmp;
int seqIdx(int[] seq){
	used[] = false;
	for(int i=0;i<dMax;i++){
		int c=0;
		for(int j=0;j<dMax;j++){
			if(!used[j]){
				if(j == seq[i]){
					seqTmp[i] = c;
					used[j] = true;
					break;
				}
				c++;
			}
		}
	}
	int res = 0;
	for(int i=dMax-1;i>=0;i--){
		res *= (dMax-i);
		res += seqTmp[i];
	}
	return res;
}

void step_insert(int[] seq,int t,int idx){
	int c=0;
	for(int i=0;i<dMax;i++){
		if(seq[i] == 0){
			if(i < idx){
				idx--;
			}
			continue;
		}
		seq[c++] = seq[i]-1; 
	}
	for(int i=idx;i<dMax;i++){
		swap(seq[i],t);
	}
}

int[][] dp;

void main(){
	int n;
	scanf("%d",&n);
	ds = new int[n];
	as = new int[n];
	
	for(int i=0;i<n;i++){
		scanf("%d",&ds[i]);
		dMax = max(dMax,ds[i]);
	}
	used = new bool[dMax];
	seqTmp = new int[dMax];
	
	for(int i=0;i<n;i++){
		scanf("%d",&as[i]);
	}
	
	int dFact = dMax.factorial;
	
	dp = dim2arr(dFact,n);
	
	
	int[] seq = new int[dMax];
	bool[] ate = new bool[dMax];
	
	for(int k=0;k<dFact;k++){
		
		sequence(seq,k);
		ate[] = false;
		int sum=0;
		foreach(i;seq){
			ate[i] = true;
			for(int j=max(0,i-ds[i]);j<min(dMax,i+ds[i]+1);j++){
				if(!ate[j])
					sum += as[i];
			}
		}
		dp[0][k] = sum;
	}
	
	for(int i;i<n-dMax;i++){
		for(int j=0;j<dFact;j++){
			for(int k=0;k<dMax+1;k++){
				int s = dp[i][j];
				sequence(seq,j);
				int c=0;
				foreach(l;seq[0..k]){
					if(dMax-l <= ds[i+l]){
						s += as[i+l];
					}
				}
				foreach(l;seq[k..dMax]){
					if(dMax-l <= ds[i+dMax]){
						s += as[i+dMax];
					}
				}
				seq.step_insert(dMax-1,k);
				int si = seq.seqIdx;
				dp[i+1][si] = max(dp[i+1][si],s);
			}
		}
	}
	
	int ri = max(0,n-dMax);
	int ans = 0;
	for(int i=0;i<dFact;i++){
		ans = max(dp[ri][i],ans);
	}
	
	printf("%d\n",ans);
}
; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/D/Source_11254/source.d'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/D/Source_11254/source.d"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"

%0 = type { i32, i32, [7 x i8] }
%object.TypeInfo_Array = type { [19 x i8*]*, i8*, %object.TypeInfo* }
%object.TypeInfo = type { [19 x i8*]*, i8* }
%object.ModuleInfo = type { i32, i32 }

@_D6source2dsAi = thread_local local_unnamed_addr global { i64, i32* } zeroinitializer, align 8 ; [#uses = 2]
@_D6source2asAi = thread_local local_unnamed_addr global { i64, i32* } zeroinitializer, align 8 ; [#uses = 2]
@_D11TypeInfo_Ai6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@_D12TypeInfo_AAi6__initZ = linkonce_odr global %object.TypeInfo_Array { [19 x i8*]* @_D14TypeInfo_Array6__vtblZ, i8* null, %object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*) } ; [#uses = 1]
@_D14TypeInfo_Array6__vtblZ = external constant [19 x i8*] ; [#uses = 1]
@.str = private unnamed_addr constant [62 x i8] c"/data/TheStack_IR/OJ_Samples/Collated/D/Source_11254/source.d\00" ; [#uses = 1]
@_D6source4dMaxi = thread_local local_unnamed_addr global i32 0, align 4 ; [#uses = 21]
@_D6source4usedAb = thread_local local_unnamed_addr global { i64, i8* } zeroinitializer, align 8 ; [#uses = 2]
@_D6source6seqTmpAi = thread_local local_unnamed_addr global { i64, i32* } zeroinitializer, align 8 ; [#uses = 2]
@_D6source2dpAAi = thread_local local_unnamed_addr global { i64, { i64, i32* }* } zeroinitializer, align 8 ; [#uses = 2]
@.str.1 = private unnamed_addr constant [3 x i8] c"%d\00" ; [#uses = 1]
@_D11TypeInfo_Ab6__initZ = external global %object.TypeInfo_Array ; [#uses = 1]
@.str.2 = private unnamed_addr constant [4 x i8] c"%d\0A\00" ; [#uses = 1]
@_D6source12__ModuleInfoZ = global %0 { i32 -2147483644, i32 0, [7 x i8] c"source\00" } ; [#uses = 1]
@_D6source11__moduleRefZ = linkonce_odr hidden global %object.ModuleInfo* bitcast (%0* @_D6source12__ModuleInfoZ to %object.ModuleInfo*), section "__minfo" ; [#uses = 1]
@__start___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@__stop___minfo = external hidden global %object.ModuleInfo* ; [#uses = 1]
@ldc.dso_slot = linkonce_odr hidden global i8* null ; [#uses = 1]
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.global_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ldc.register_dso, i8* bitcast (void ()* @ldc.register_dso to i8*) }] ; [#uses = 0]
@llvm.used = appending global [1 x i8*] [i8* bitcast (%object.ModuleInfo** @_D6source11__moduleRefZ to i8*)], section "llvm.metadata" ; [#uses = 0]

; [#uses = 0]
; Function Attrs: uwtable
define { i64, { i64, i32* }* } @_D6source7dim2arrFiiZAAi(i32 %h_arg, i32 %w_arg) local_unnamed_addr #0 {
  %1 = mul i32 %w_arg, %h_arg                     ; [#uses = 2]
  %2 = sext i32 %1 to i64                         ; [#uses = 2]
  %.gc_mem = tail call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %2) #1 ; [#uses = 1]
  %.ptr = extractvalue { i64, i8* } %.gc_mem, 1   ; [#uses = 1]
  %3 = bitcast i8* %.ptr to i32*                  ; [#uses = 1]
  %4 = sext i32 %h_arg to i64                     ; [#uses = 2]
  %.gc_mem1 = tail call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_AAi6__initZ to %object.TypeInfo*), i64 %4) #1 ; [#uses = 1]
  %.ptr2 = extractvalue { i64, i8* } %.gc_mem1, 1 ; [#uses = 1]
  %5 = bitcast i8* %.ptr2 to { i64, i32* }*       ; [#uses = 3]
  %6 = icmp sgt i32 %h_arg, 0                     ; [#uses = 1]
  br i1 %6, label %forbody.preheader, label %endfor

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

bounds.ok:                                        ; preds = %forbody.preheader, %bounds.ok4
  %indvars.iv = phi i64 [ 0, %forbody.preheader ], [ %indvars.iv.next, %bounds.ok4 ] ; [#uses = 4, type = i64]
  %7 = trunc i64 %indvars.iv to i32               ; [#uses = 1]
  %8 = mul i32 %7, %w_arg                         ; [#uses = 2]
  %9 = sext i32 %8 to i64                         ; [#uses = 3]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 3]
  %10 = trunc i64 %indvars.iv.next to i32         ; [#uses = 1]
  %11 = mul i32 %10, %w_arg                       ; [#uses = 3]
  %12 = sext i32 %11 to i64                       ; [#uses = 2]
  %bounds.cmp.up = icmp ule i32 %11, %1           ; [#uses = 1]
  %bounds.cmp.lo = icmp uge i32 %11, %8           ; [#uses = 1]
  %13 = and i1 %bounds.cmp.up, %bounds.cmp.lo     ; [#uses = 1]
  br i1 %13, label %bounds.ok4, label %bounds.fail5

bounds.ok4:                                       ; preds = %bounds.ok
  %lowerbound = getelementptr inbounds i32, i32* %3, i64 %9 ; [#uses = 1, type = i32*]
  %14 = sub nsw i64 %12, %9                       ; [#uses = 1]
  %15 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %5, i64 %indvars.iv, i32 0 ; [#uses = 1, type = i64*]
  store i64 %14, i64* %15, align 8
  %16 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %5, i64 %indvars.iv, i32 1 ; [#uses = 1, type = i32**]
  store i32* %lowerbound, i32** %16, align 8
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count ; [#uses = 1]
  br i1 %exitcond.not, label %endfor, label %bounds.ok

bounds.fail5:                                     ; preds = %bounds.ok
  tail call void @_d_arraybounds_slice({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 12, i64 %9, i64 %12, i64 %2) #2
  unreachable

endfor:                                           ; preds = %bounds.ok4, %0
  %17 = insertvalue { i64, { i64, i32* }* } undef, i64 %4, 0 ; [#uses = 1]
  %.fca.1.insert17 = insertvalue { i64, { i64, i32* }* } %17, { i64, i32* }* %5, 1 ; [#uses = 1]
  ret { i64, { i64, i32* }* } %.fca.1.insert17
}

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

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

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

; [#uses = 0]
; Function Attrs: nounwind readnone uwtable
define i32 @_D6source9factorialFiZi(i32 %a_arg) local_unnamed_addr #3 {
  %1 = icmp slt i32 %a_arg, 2                     ; [#uses = 1]
  br i1 %1, label %if, label %else.preheader

else.preheader:                                   ; preds = %0
  %2 = add i32 %a_arg, -1                         ; [#uses = 3]
  %min.iters.check = icmp ult i32 %2, 8           ; [#uses = 1]
  br i1 %min.iters.check, label %else.preheader8, label %vector.ph

else.preheader8:                                  ; preds = %middle.block, %else.preheader
  %a_arg.tr5.ph = phi i32 [ %a_arg, %else.preheader ], [ %ind.end, %middle.block ] ; [#uses = 1, type = i32]
  %accumulator.tr4.ph = phi i32 [ 1, %else.preheader ], [ %17, %middle.block ] ; [#uses = 1, type = i32]
  br label %else

vector.ph:                                        ; preds = %else.preheader
  %n.vec = and i32 %2, -8                         ; [#uses = 3]
  %ind.end = sub i32 %a_arg, %n.vec               ; [#uses = 1]
  %.splatinsert = insertelement <4 x i32> undef, i32 %a_arg, i32 0 ; [#uses = 1]
  %.splat = shufflevector <4 x i32> %.splatinsert, <4 x i32> undef, <4 x i32> zeroinitializer ; [#uses = 1]
  %induction = add <4 x i32> %.splat, <i32 0, i32 -1, i32 -2, i32 -3> ; [#uses = 2]
  %3 = add i32 %n.vec, -8                         ; [#uses = 2]
  %4 = lshr exact i32 %3, 3                       ; [#uses = 1]
  %5 = add nuw nsw i32 %4, 1                      ; [#uses = 2]
  %xtraiter = and i32 %5, 3                       ; [#uses = 2]
  %6 = icmp ult i32 %3, 24                        ; [#uses = 1]
  br i1 %6, label %middle.block.unr-lcssa, label %vector.ph.new

vector.ph.new:                                    ; preds = %vector.ph
  %unroll_iter = and i32 %5, 1073741820           ; [#uses = 1]
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph.new
  %vec.ind = phi <4 x i32> [ %induction, %vector.ph.new ], [ %vec.ind.next.3, %vector.body ] ; [#uses = 9, type = <4 x i32>]
  %vec.phi = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph.new ], [ %13, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi7 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph.new ], [ %14, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %niter = phi i32 [ %unroll_iter, %vector.ph.new ], [ %niter.nsub.3, %vector.body ] ; [#uses = 1, type = i32]
  %step.add = add <4 x i32> %vec.ind, <i32 -4, i32 -4, i32 -4, i32 -4> ; [#uses = 1]
  %7 = mul <4 x i32> %vec.ind, %vec.phi           ; [#uses = 1]
  %8 = mul <4 x i32> %step.add, %vec.phi7         ; [#uses = 1]
  %vec.ind.next = add <4 x i32> %vec.ind, <i32 -8, i32 -8, i32 -8, i32 -8> ; [#uses = 1]
  %step.add.1 = add <4 x i32> %vec.ind, <i32 -12, i32 -12, i32 -12, i32 -12> ; [#uses = 1]
  %9 = mul <4 x i32> %vec.ind.next, %7            ; [#uses = 1]
  %10 = mul <4 x i32> %step.add.1, %8             ; [#uses = 1]
  %vec.ind.next.1 = add <4 x i32> %vec.ind, <i32 -16, i32 -16, i32 -16, i32 -16> ; [#uses = 1]
  %step.add.2 = add <4 x i32> %vec.ind, <i32 -20, i32 -20, i32 -20, i32 -20> ; [#uses = 1]
  %11 = mul <4 x i32> %vec.ind.next.1, %9         ; [#uses = 1]
  %12 = mul <4 x i32> %step.add.2, %10            ; [#uses = 1]
  %vec.ind.next.2 = add <4 x i32> %vec.ind, <i32 -24, i32 -24, i32 -24, i32 -24> ; [#uses = 1]
  %step.add.3 = add <4 x i32> %vec.ind, <i32 -28, i32 -28, i32 -28, i32 -28> ; [#uses = 1]
  %13 = mul <4 x i32> %vec.ind.next.2, %11        ; [#uses = 3]
  %14 = mul <4 x i32> %step.add.3, %12            ; [#uses = 3]
  %vec.ind.next.3 = add <4 x i32> %vec.ind, <i32 -32, i32 -32, i32 -32, i32 -32> ; [#uses = 2]
  %niter.nsub.3 = add i32 %niter, -4              ; [#uses = 2]
  %niter.ncmp.3 = icmp eq i32 %niter.nsub.3, 0    ; [#uses = 1]
  br i1 %niter.ncmp.3, label %middle.block.unr-lcssa, label %vector.body, !llvm.loop !4

middle.block.unr-lcssa:                           ; preds = %vector.body, %vector.ph
  %.lcssa10.ph = phi <4 x i32> [ undef, %vector.ph ], [ %13, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %.lcssa9.ph = phi <4 x i32> [ undef, %vector.ph ], [ %14, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.ind.unr = phi <4 x i32> [ %induction, %vector.ph ], [ %vec.ind.next.3, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi.unr = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph ], [ %13, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi7.unr = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph ], [ %14, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %lcmp.mod.not = icmp eq i32 %xtraiter, 0        ; [#uses = 1]
  br i1 %lcmp.mod.not, label %middle.block, label %vector.body.epil

vector.body.epil:                                 ; preds = %middle.block.unr-lcssa, %vector.body.epil
  %vec.ind.epil = phi <4 x i32> [ %vec.ind.next.epil, %vector.body.epil ], [ %vec.ind.unr, %middle.block.unr-lcssa ] ; [#uses = 3, type = <4 x i32>]
  %vec.phi.epil = phi <4 x i32> [ %15, %vector.body.epil ], [ %vec.phi.unr, %middle.block.unr-lcssa ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi7.epil = phi <4 x i32> [ %16, %vector.body.epil ], [ %vec.phi7.unr, %middle.block.unr-lcssa ] ; [#uses = 1, type = <4 x i32>]
  %epil.iter = phi i32 [ %epil.iter.sub, %vector.body.epil ], [ %xtraiter, %middle.block.unr-lcssa ] ; [#uses = 1, type = i32]
  %step.add.epil = add <4 x i32> %vec.ind.epil, <i32 -4, i32 -4, i32 -4, i32 -4> ; [#uses = 1]
  %15 = mul <4 x i32> %vec.ind.epil, %vec.phi.epil ; [#uses = 2]
  %16 = mul <4 x i32> %step.add.epil, %vec.phi7.epil ; [#uses = 2]
  %vec.ind.next.epil = add <4 x i32> %vec.ind.epil, <i32 -8, i32 -8, i32 -8, i32 -8> ; [#uses = 1]
  %epil.iter.sub = add i32 %epil.iter, -1         ; [#uses = 2]
  %epil.iter.cmp.not = icmp eq i32 %epil.iter.sub, 0 ; [#uses = 1]
  br i1 %epil.iter.cmp.not, label %middle.block, label %vector.body.epil, !llvm.loop !6

middle.block:                                     ; preds = %vector.body.epil, %middle.block.unr-lcssa
  %.lcssa10 = phi <4 x i32> [ %.lcssa10.ph, %middle.block.unr-lcssa ], [ %15, %vector.body.epil ] ; [#uses = 1, type = <4 x i32>]
  %.lcssa9 = phi <4 x i32> [ %.lcssa9.ph, %middle.block.unr-lcssa ], [ %16, %vector.body.epil ] ; [#uses = 1, type = <4 x i32>]
  %bin.rdx = mul <4 x i32> %.lcssa9, %.lcssa10    ; [#uses = 1]
  %17 = call i32 @llvm.experimental.vector.reduce.mul.v4i32(<4 x i32> %bin.rdx) ; [#uses = 2]
  %cmp.n = icmp eq i32 %2, %n.vec                 ; [#uses = 1]
  br i1 %cmp.n, label %if, label %else.preheader8

if:                                               ; preds = %else, %middle.block, %0
  %accumulator.tr.lcssa = phi i32 [ 1, %0 ], [ %17, %middle.block ], [ %19, %else ] ; [#uses = 1, type = i32]
  ret i32 %accumulator.tr.lcssa

else:                                             ; preds = %else.preheader8, %else
  %a_arg.tr5 = phi i32 [ %18, %else ], [ %a_arg.tr5.ph, %else.preheader8 ] ; [#uses = 3, type = i32]
  %accumulator.tr4 = phi i32 [ %19, %else ], [ %accumulator.tr4.ph, %else.preheader8 ] ; [#uses = 1, type = i32]
  %18 = add nsw i32 %a_arg.tr5, -1                ; [#uses = 1]
  %19 = mul i32 %a_arg.tr5, %accumulator.tr4      ; [#uses = 2]
  %20 = icmp slt i32 %a_arg.tr5, 3                ; [#uses = 1]
  br i1 %20, label %if, label %else, !llvm.loop !8
}

; [#uses = 0]
; Function Attrs: uwtable
define i32 @_D6source6unUsedFAbiZi(i32 %idx_arg, { i64, i8* } %used_arg) local_unnamed_addr #0 {
  %used_arg.fca.0.extract = extractvalue { i64, i8* } %used_arg, 0 ; [#uses = 2]
  %used_arg.fca.1.extract = extractvalue { i64, i8* } %used_arg, 1 ; [#uses = 2]
  %1 = trunc i64 %used_arg.fca.0.extract to i32   ; [#uses = 1]
  %2 = icmp sgt i32 %1, 0                         ; [#uses = 1]
  br i1 %2, label %forbody.preheader, label %assertFailed

forbody.preheader:                                ; preds = %0
  %wide.trip.count = and i64 %used_arg.fca.0.extract, 4294967295 ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %forinc, %forbody.preheader
  %indvars.iv = phi i64 [ 0, %forbody.preheader ], [ %indvars.iv.next, %forinc ] ; [#uses = 4, type = i64]
  %idx.013 = phi i32 [ %idx_arg, %forbody.preheader ], [ %idx.1, %forinc ] ; [#uses = 3, type = i32]
  %3 = getelementptr inbounds i8, i8* %used_arg.fca.1.extract, i64 %indvars.iv ; [#uses = 1, type = i8*]
  %4 = load i8, i8* %3, align 1, !range !10       ; [#uses = 1]
  %.not = icmp eq i8 %4, 0                        ; [#uses = 1]
  br i1 %.not, label %if, label %forinc

if:                                               ; preds = %forbody
  %5 = add i32 %idx.013, -1                       ; [#uses = 1]
  %6 = icmp eq i32 %idx.013, 0                    ; [#uses = 1]
  br i1 %6, label %if3, label %forinc

if3:                                              ; preds = %if
  %7 = trunc i64 %indvars.iv to i32               ; [#uses = 1]
  %8 = and i64 %indvars.iv, 4294967295            ; [#uses = 1]
  %9 = getelementptr inbounds i8, i8* %used_arg.fca.1.extract, i64 %8 ; [#uses = 1, type = i8*]
  store i8 1, i8* %9, align 1
  ret i32 %7

forinc:                                           ; preds = %forbody, %if
  %idx.1 = phi i32 [ %5, %if ], [ %idx.013, %forbody ] ; [#uses = 1, type = i32]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 2]
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count ; [#uses = 1]
  br i1 %exitcond.not, label %assertFailed, label %forbody

assertFailed:                                     ; preds = %forinc, %0
  tail call void @_d_assert({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 33) #2
  unreachable
}

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

; [#uses = 0]
; Function Attrs: uwtable
define void @_D6source8sequenceFAiiZv(i32 %t_arg, { i64, i32* } %dest_arg) local_unnamed_addr #0 {
  %dest_arg.fca.0.extract = extractvalue { i64, i32* } %dest_arg, 0 ; [#uses = 2]
  %dest_arg.fca.1.extract = extractvalue { i64, i32* } %dest_arg, 1 ; [#uses = 1]
  %.ptr = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 1]
  %.len = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 1]
  tail call void @llvm.memset.p0i8.i64(i8* align 1 %.ptr, i8 0, i64 %.len, i1 false)
  %1 = load i32, i32* @_D6source4dMaxi, align 4   ; [#uses = 2]
  %2 = icmp sgt i32 %1, 0                         ; [#uses = 1]
  br i1 %2, label %forbody, label %endfor

forbody:                                          ; preds = %0, %_D6source6unUsedFAbiZi.exit
  %3 = phi i32 [ %17, %_D6source6unUsedFAbiZi.exit ], [ %1, %0 ] ; [#uses = 1, type = i32]
  %i.015 = phi i32 [ %20, %_D6source6unUsedFAbiZi.exit ], [ 0, %0 ] ; [#uses = 4, type = i32]
  %t.014 = phi i32 [ %19, %_D6source6unUsedFAbiZi.exit ], [ %t_arg, %0 ] ; [#uses = 2, type = i32]
  %4 = sext i32 %i.015 to i64                     ; [#uses = 3]
  %bounds.cmp = icmp ugt i64 %dest_arg.fca.0.extract, %4 ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %forbody
  %5 = getelementptr inbounds i32, i32* %dest_arg.fca.1.extract, i64 %4 ; [#uses = 1, type = i32*]
  %.unpack = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 2]
  %.unpack9 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 2]
  %6 = trunc i64 %.unpack to i32                  ; [#uses = 1]
  %7 = icmp sgt i32 %6, 0                         ; [#uses = 1]
  br i1 %7, label %forbody.preheader.i, label %assertFailed.i

forbody.preheader.i:                              ; preds = %bounds.ok
  %8 = sub i32 %3, %i.015                         ; [#uses = 1]
  %9 = srem i32 %t.014, %8                        ; [#uses = 1]
  %wide.trip.count.i = and i64 %.unpack, 4294967295 ; [#uses = 1]
  br label %forbody.i

forbody.i:                                        ; preds = %forinc.i, %forbody.preheader.i
  %indvars.iv.i = phi i64 [ 0, %forbody.preheader.i ], [ %indvars.iv.next.i, %forinc.i ] ; [#uses = 4, type = i64]
  %idx.013.i = phi i32 [ %9, %forbody.preheader.i ], [ %idx.1.i, %forinc.i ] ; [#uses = 3, type = i32]
  %10 = getelementptr inbounds i8, i8* %.unpack9, i64 %indvars.iv.i ; [#uses = 1, type = i8*]
  %11 = load i8, i8* %10, align 1, !range !10     ; [#uses = 1]
  %.not.i = icmp eq i8 %11, 0                     ; [#uses = 1]
  br i1 %.not.i, label %if.i, label %forinc.i

if.i:                                             ; preds = %forbody.i
  %12 = add i32 %idx.013.i, -1                    ; [#uses = 1]
  %13 = icmp eq i32 %idx.013.i, 0                 ; [#uses = 1]
  br i1 %13, label %_D6source6unUsedFAbiZi.exit, label %forinc.i

forinc.i:                                         ; preds = %if.i, %forbody.i
  %idx.1.i = phi i32 [ %12, %if.i ], [ %idx.013.i, %forbody.i ] ; [#uses = 1, type = i32]
  %indvars.iv.next.i = add nuw nsw i64 %indvars.iv.i, 1 ; [#uses = 2]
  %exitcond.not.i = icmp eq i64 %indvars.iv.next.i, %wide.trip.count.i ; [#uses = 1]
  br i1 %exitcond.not.i, label %assertFailed.i, label %forbody.i

assertFailed.i:                                   ; preds = %bounds.ok, %forinc.i
  tail call void @_d_assert({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 33) #2
  unreachable

_D6source6unUsedFAbiZi.exit:                      ; preds = %if.i
  %14 = trunc i64 %indvars.iv.i to i32            ; [#uses = 1]
  %15 = and i64 %indvars.iv.i, 4294967295         ; [#uses = 1]
  %16 = getelementptr inbounds i8, i8* %.unpack9, i64 %15 ; [#uses = 1, type = i8*]
  store i8 1, i8* %16, align 1
  store i32 %14, i32* %5, align 4
  %17 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 3]
  %18 = sub i32 %17, %i.015                       ; [#uses = 1]
  %19 = sdiv i32 %t.014, %18                      ; [#uses = 1]
  %20 = add i32 %i.015, 1                         ; [#uses = 2]
  %21 = icmp sgt i32 %17, %20                     ; [#uses = 1]
  br i1 %21, label %forbody, label %endfor

bounds.fail:                                      ; preds = %forbody
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 42, i64 %4, i64 %dest_arg.fca.0.extract) #2
  unreachable

endfor:                                           ; preds = %_D6source6unUsedFAbiZi.exit, %0
  ret void
}

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

; [#uses = 1]
; Function Attrs: uwtable
define i32 @_D6source6seqIdxFAiZi({ i64, i32* } %seq_arg) local_unnamed_addr #0 {
  %seq_arg.fca.0.extract = extractvalue { i64, i32* } %seq_arg, 0 ; [#uses = 2]
  %seq_arg.fca.1.extract = extractvalue { i64, i32* } %seq_arg, 1 ; [#uses = 1]
  %.ptr = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 1]
  %.len = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 1]
  tail call void @llvm.memset.p0i8.i64(i8* align 1 %.ptr, i8 0, i64 %.len, i1 false)
  %1 = load i32, i32* @_D6source4dMaxi, align 4   ; [#uses = 3]
  %2 = icmp sgt i32 %1, 0                         ; [#uses = 1]
  br i1 %2, label %forcond1.preheader, label %forcond25.preheader

forcond1.preheader:                               ; preds = %0, %forinc
  %3 = phi i32 [ %19, %forinc ], [ %1, %0 ]       ; [#uses = 5, type = i32]
  %indvars.iv110 = phi i64 [ %indvars.iv.next111, %forinc ], [ 0, %0 ] ; [#uses = 7, type = i64]
  %4 = icmp sgt i32 %3, 0                         ; [#uses = 1]
  br i1 %4, label %forbody2.lr.ph, label %forinc

forbody2.lr.ph:                                   ; preds = %forcond1.preheader
  %.len5 = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 4]
  %.ptr6 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 2]
  %bounds.cmp8 = icmp ugt i64 %seq_arg.fca.0.extract, %indvars.iv110 ; [#uses = 1]
  %5 = getelementptr inbounds i32, i32* %seq_arg.fca.1.extract, i64 %indvars.iv110 ; [#uses = 1, type = i32*]
  %wide.trip.count108 = zext i32 %3 to i64        ; [#uses = 2]
  br i1 %bounds.cmp8, label %forbody2.us, label %forbody2

forbody2.us:                                      ; preds = %forbody2.lr.ph, %forinc3.us
  %indvars.iv105 = phi i64 [ %indvars.iv.next106, %forinc3.us ], [ 0, %forbody2.lr.ph ] ; [#uses = 5, type = i64]
  %c.074.us = phi i32 [ %c.1.us, %forinc3.us ], [ 0, %forbody2.lr.ph ] ; [#uses = 3, type = i32]
  %exitcond107.not = icmp eq i64 %indvars.iv105, %.len5 ; [#uses = 1]
  br i1 %exitcond107.not, label %bounds.fail, label %bounds.ok.us

bounds.ok.us:                                     ; preds = %forbody2.us
  %6 = getelementptr inbounds i8, i8* %.ptr6, i64 %indvars.iv105 ; [#uses = 1, type = i8*]
  %7 = load i8, i8* %6, align 1, !range !10       ; [#uses = 1]
  %.not.us = icmp eq i8 %7, 0                     ; [#uses = 1]
  br i1 %.not.us, label %bounds.ok9.us, label %forinc3.us

bounds.ok9.us:                                    ; preds = %bounds.ok.us
  %8 = load i32, i32* %5, align 4                 ; [#uses = 1]
  %9 = zext i32 %8 to i64                         ; [#uses = 1]
  %10 = icmp eq i64 %indvars.iv105, %9            ; [#uses = 1]
  br i1 %10, label %if12, label %endif13.us

endif13.us:                                       ; preds = %bounds.ok9.us
  %11 = add i32 %c.074.us, 1                      ; [#uses = 1]
  br label %forinc3.us

forinc3.us:                                       ; preds = %endif13.us, %bounds.ok.us
  %c.1.us = phi i32 [ %11, %endif13.us ], [ %c.074.us, %bounds.ok.us ] ; [#uses = 1, type = i32]
  %indvars.iv.next106 = add nuw nsw i64 %indvars.iv105, 1 ; [#uses = 2]
  %exitcond109.not = icmp eq i64 %indvars.iv.next106, %wide.trip.count108 ; [#uses = 1]
  br i1 %exitcond109.not, label %forinc, label %forbody2.us

forcond25.preheader:                              ; preds = %forinc, %0
  %.lcssa65 = phi i32 [ %1, %0 ], [ %19, %forinc ] ; [#uses = 2, type = i32]
  %i24.071 = add i32 %.lcssa65, -1                ; [#uses = 2]
  %12 = icmp sgt i32 %i24.071, -1                 ; [#uses = 1]
  br i1 %12, label %forbody26.lr.ph, label %endfor28

forbody26.lr.ph:                                  ; preds = %forcond25.preheader
  %.len29 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %.ptr33 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 1), align 8 ; [#uses = 1]
  br label %forbody26

forbody2:                                         ; preds = %forbody2.lr.ph, %forinc3
  %indvars.iv = phi i64 [ %indvars.iv.next, %forinc3 ], [ 0, %forbody2.lr.ph ] ; [#uses = 3, type = i64]
  %exitcond.not = icmp eq i64 %indvars.iv, %.len5 ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody2
  %13 = getelementptr inbounds i8, i8* %.ptr6, i64 %indvars.iv ; [#uses = 1, type = i8*]
  %14 = load i8, i8* %13, align 1, !range !10     ; [#uses = 1]
  %.not = icmp eq i8 %14, 0                       ; [#uses = 1]
  br i1 %.not, label %bounds.fail10, label %forinc3

if12:                                             ; preds = %bounds.ok9.us
  %15 = and i64 %indvars.iv105, 4294967295        ; [#uses = 3]
  %.len14 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp15 = icmp ugt i64 %.len14, %indvars.iv110 ; [#uses = 1]
  br i1 %bounds.cmp15, label %bounds.ok16, label %bounds.fail17

bounds.ok16:                                      ; preds = %if12
  %.ptr18 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %16 = getelementptr inbounds i32, i32* %.ptr18, i64 %indvars.iv110 ; [#uses = 1, type = i32*]
  store i32 %c.074.us, i32* %16, align 4
  %.len19 = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp20 = icmp ugt i64 %.len19, %15       ; [#uses = 1]
  br i1 %bounds.cmp20, label %bounds.ok21, label %bounds.fail22

bounds.ok21:                                      ; preds = %bounds.ok16
  %.ptr23 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 1]
  %17 = getelementptr inbounds i8, i8* %.ptr23, i64 %15 ; [#uses = 1, type = i8*]
  store i8 1, i8* %17, align 1
  %.pre = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 1]
  br label %forinc

bounds.fail22:                                    ; preds = %bounds.ok16
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 56, i64 %15, i64 %.len19) #2
  unreachable

bounds.fail17:                                    ; preds = %if12
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 55, i64 %indvars.iv110, i64 %.len14) #2
  unreachable

bounds.fail10:                                    ; preds = %bounds.ok
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 54, i64 %indvars.iv110, i64 %seq_arg.fca.0.extract) #2
  unreachable

bounds.fail:                                      ; preds = %forbody2, %forbody2.us
  %18 = and i64 %.len5, 4294967295                ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 53, i64 %18, i64 %.len5) #2
  unreachable

forinc3:                                          ; preds = %bounds.ok
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 2]
  %exitcond104.not = icmp eq i64 %indvars.iv.next, %wide.trip.count108 ; [#uses = 1]
  br i1 %exitcond104.not, label %forinc, label %forbody2

forinc:                                           ; preds = %forinc3, %forinc3.us, %forcond1.preheader, %bounds.ok21
  %19 = phi i32 [ %3, %forcond1.preheader ], [ %.pre, %bounds.ok21 ], [ %3, %forinc3.us ], [ %3, %forinc3 ] ; [#uses = 3, type = i32]
  %indvars.iv.next111 = add nuw nsw i64 %indvars.iv110, 1 ; [#uses = 2]
  %20 = sext i32 %19 to i64                       ; [#uses = 1]
  %21 = icmp slt i64 %indvars.iv.next111, %20     ; [#uses = 1]
  br i1 %21, label %forcond1.preheader, label %forcond25.preheader

forbody26:                                        ; preds = %forbody26.lr.ph, %bounds.ok31
  %i24.073 = phi i32 [ %i24.071, %forbody26.lr.ph ], [ %i24.0, %bounds.ok31 ] ; [#uses = 4, type = i32]
  %res.072 = phi i32 [ 0, %forbody26.lr.ph ], [ %27, %bounds.ok31 ] ; [#uses = 1, type = i32]
  %22 = zext i32 %i24.073 to i64                  ; [#uses = 2]
  %bounds.cmp30 = icmp ugt i64 %.len29, %22       ; [#uses = 1]
  br i1 %bounds.cmp30, label %bounds.ok31, label %bounds.fail32

bounds.ok31:                                      ; preds = %forbody26
  %23 = sub i32 %.lcssa65, %i24.073               ; [#uses = 1]
  %24 = mul i32 %23, %res.072                     ; [#uses = 1]
  %25 = getelementptr inbounds i32, i32* %.ptr33, i64 %22 ; [#uses = 1, type = i32*]
  %26 = load i32, i32* %25, align 4               ; [#uses = 1]
  %27 = add i32 %26, %24                          ; [#uses = 2]
  %i24.0 = add i32 %i24.073, -1                   ; [#uses = 2]
  %28 = icmp sgt i32 %i24.0, -1                   ; [#uses = 1]
  br i1 %28, label %forbody26, label %endfor28

bounds.fail32:                                    ; preds = %forbody26
  %29 = zext i32 %i24.073 to i64                  ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 66, i64 %29, i64 %.len29) #2
  unreachable

endfor28:                                         ; preds = %bounds.ok31, %forcond25.preheader
  %res.0.lcssa = phi i32 [ 0, %forcond25.preheader ], [ %27, %bounds.ok31 ] ; [#uses = 1, type = i32]
  ret i32 %res.0.lcssa
}

; [#uses = 1]
; Function Attrs: uwtable
define void @_D6source11step_insertFAiiiZv(i32 %idx_arg, i32 %t_arg, { i64, i32* } %seq_arg) local_unnamed_addr #0 {
  %seq_arg.fca.0.extract = extractvalue { i64, i32* } %seq_arg, 0 ; [#uses = 8]
  %seq_arg.fca.1.extract = extractvalue { i64, i32* } %seq_arg, 1 ; [#uses = 3]
  %1 = load i32, i32* @_D6source4dMaxi, align 4   ; [#uses = 3]
  %2 = icmp sgt i32 %1, 0                         ; [#uses = 1]
  br i1 %2, label %forbody, label %forcond14.preheader

forcond14.preheader:                              ; preds = %forinc, %0
  %3 = phi i32 [ %1, %0 ], [ %19, %forinc ]       ; [#uses = 1, type = i32]
  %idx.0.lcssa = phi i32 [ %idx_arg, %0 ], [ %idx.1, %forinc ] ; [#uses = 2, type = i32]
  %4 = icmp slt i32 %idx.0.lcssa, %3              ; [#uses = 1]
  br i1 %4, label %forbody15.preheader, label %endfor17

forbody15.preheader:                              ; preds = %forcond14.preheader
  %5 = sext i32 %idx.0.lcssa to i64               ; [#uses = 3]
  %6 = icmp ugt i64 %seq_arg.fca.0.extract, %5    ; [#uses = 1]
  %umax = select i1 %6, i64 %seq_arg.fca.0.extract, i64 %5 ; [#uses = 2]
  br label %forbody15

forbody:                                          ; preds = %0, %forinc
  %7 = phi i32 [ %19, %forinc ], [ %1, %0 ]       ; [#uses = 1, type = i32]
  %indvars.iv54 = phi i64 [ %indvars.iv.next55, %forinc ], [ 0, %0 ] ; [#uses = 4, type = i64]
  %c.047 = phi i32 [ %c.1, %forinc ], [ 0, %0 ]   ; [#uses = 3, type = i32]
  %idx.046 = phi i32 [ %idx.1, %forinc ], [ %idx_arg, %0 ] ; [#uses = 3, type = i32]
  %exitcond56.not = icmp eq i64 %indvars.iv54, %seq_arg.fca.0.extract ; [#uses = 1]
  br i1 %exitcond56.not, label %bounds.fail, label %bounds.ok

bounds.ok:                                        ; preds = %forbody
  %8 = getelementptr inbounds i32, i32* %seq_arg.fca.1.extract, i64 %indvars.iv54 ; [#uses = 1, type = i32*]
  %9 = load i32, i32* %8, align 4                 ; [#uses = 2]
  %10 = icmp eq i32 %9, 0                         ; [#uses = 1]
  br i1 %10, label %if, label %endif

if:                                               ; preds = %bounds.ok
  %11 = sext i32 %idx.046 to i64                  ; [#uses = 1]
  %12 = icmp slt i64 %indvars.iv54, %11           ; [#uses = 1]
  %13 = sext i1 %12 to i32                        ; [#uses = 1]
  %spec.select = add i32 %idx.046, %13            ; [#uses = 1]
  br label %forinc

endif:                                            ; preds = %bounds.ok
  %14 = sext i32 %c.047 to i64                    ; [#uses = 3]
  %bounds.cmp4 = icmp ugt i64 %seq_arg.fca.0.extract, %14 ; [#uses = 1]
  br i1 %bounds.cmp4, label %bounds.ok10, label %bounds.fail6

bounds.ok10:                                      ; preds = %endif
  %15 = add i32 %c.047, 1                         ; [#uses = 1]
  %16 = getelementptr inbounds i32, i32* %seq_arg.fca.1.extract, i64 %14 ; [#uses = 1, type = i32*]
  %17 = add i32 %9, -1                            ; [#uses = 1]
  store i32 %17, i32* %16, align 4
  %.pre = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 1]
  br label %forinc

bounds.fail6:                                     ; preds = %endif
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 80, i64 %14, i64 %seq_arg.fca.0.extract) #2
  unreachable

bounds.fail:                                      ; preds = %forbody
  %18 = and i64 %seq_arg.fca.0.extract, 4294967295 ; [#uses = 1]
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 74, i64 %18, i64 %seq_arg.fca.0.extract) #2
  unreachable

forinc:                                           ; preds = %if, %bounds.ok10
  %19 = phi i32 [ %.pre, %bounds.ok10 ], [ %7, %if ] ; [#uses = 3, type = i32]
  %idx.1 = phi i32 [ %idx.046, %bounds.ok10 ], [ %spec.select, %if ] ; [#uses = 2, type = i32]
  %c.1 = phi i32 [ %15, %bounds.ok10 ], [ %c.047, %if ] ; [#uses = 1, type = i32]
  %indvars.iv.next55 = add nuw nsw i64 %indvars.iv54, 1 ; [#uses = 2]
  %20 = trunc i64 %indvars.iv.next55 to i32       ; [#uses = 1]
  %21 = icmp sgt i32 %19, %20                     ; [#uses = 1]
  br i1 %21, label %forbody, label %forcond14.preheader

forbody15:                                        ; preds = %forbody15.preheader, %bounds.ok20
  %indvars.iv = phi i64 [ %5, %forbody15.preheader ], [ %indvars.iv.next, %bounds.ok20 ] ; [#uses = 3, type = i64]
  %t.044 = phi i32 [ %t_arg, %forbody15.preheader ], [ %23, %bounds.ok20 ] ; [#uses = 1, type = i32]
  %exitcond.not = icmp eq i64 %indvars.iv, %umax  ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail21, label %bounds.ok20

bounds.ok20:                                      ; preds = %forbody15
  %22 = getelementptr inbounds i32, i32* %seq_arg.fca.1.extract, i64 %indvars.iv ; [#uses = 2, type = i32*]
  %23 = load i32, i32* %22, align 4               ; [#uses = 1]
  store i32 %t.044, i32* %22, align 4
  %indvars.iv.next = add nsw i64 %indvars.iv, 1   ; [#uses = 2]
  %24 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 1]
  %25 = sext i32 %24 to i64                       ; [#uses = 1]
  %26 = icmp slt i64 %indvars.iv.next, %25        ; [#uses = 1]
  br i1 %26, label %forbody15, label %endfor17

bounds.fail21:                                    ; preds = %forbody15
  tail call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 83, i64 %umax, i64 %seq_arg.fca.0.extract) #2
  unreachable

endfor17:                                         ; preds = %bounds.ok20, %forcond14.preheader
  ret void
}

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

; [#uses = 1]
; Function Attrs: uwtable
define i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #5 {
  %n = alloca i32, align 4                        ; [#uses = 10, size/byte = 4]
  store i32 0, i32* %n, align 4
  %1 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* nonnull %n) #7 ; [#uses = 0]
  %2 = load i32, i32* %n, align 4                 ; [#uses = 1]
  %3 = sext i32 %2 to i64                         ; [#uses = 2]
  %.gc_mem = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %3) #1 ; [#uses = 1]
  %.ptr = extractvalue { i64, i8* } %.gc_mem, 1   ; [#uses = 1]
  store i64 %3, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8
  store i8* %.ptr, i8** bitcast (i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1) to i8**), align 8
  %4 = load i32, i32* %n, align 4                 ; [#uses = 1]
  %5 = sext i32 %4 to i64                         ; [#uses = 2]
  %.gc_mem1 = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %5) #1 ; [#uses = 1]
  %.ptr2 = extractvalue { i64, i8* } %.gc_mem1, 1 ; [#uses = 1]
  store i64 %5, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 0), align 8
  store i8* %.ptr2, i8** bitcast (i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 1) to i8**), align 8
  %6 = load i32, i32* %n, align 4                 ; [#uses = 1]
  %7 = icmp sgt i32 %6, 0                         ; [#uses = 1]
  br i1 %7, label %forbody.preheader, label %.endfor_crit_edge

.endfor_crit_edge:                                ; preds = %0
  %.pre = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 1]
  br label %endfor

forbody.preheader:                                ; preds = %0
  %.len.pre = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8 ; [#uses = 1]
  br label %forbody

forbody:                                          ; preds = %forbody.preheader, %bounds.ok6
  %.len = phi i64 [ %.len.pre, %forbody.preheader ], [ %.len4, %bounds.ok6 ] ; [#uses = 2, type = i64]
  %indvars.iv668 = phi i64 [ 0, %forbody.preheader ], [ %indvars.iv.next669, %bounds.ok6 ] ; [#uses = 7, type = i64]
  %bounds.cmp = icmp ugt i64 %.len, %indvars.iv668 ; [#uses = 1]
  br i1 %bounds.cmp, label %bounds.ok, label %bounds.fail

bounds.ok:                                        ; preds = %forbody
  %.ptr3 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %8 = getelementptr inbounds i32, i32* %.ptr3, i64 %indvars.iv668 ; [#uses = 1, type = i32*]
  %9 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %8) #7 ; [#uses = 0]
  %.len4 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8 ; [#uses = 3]
  %bounds.cmp5 = icmp ugt i64 %.len4, %indvars.iv668 ; [#uses = 1]
  br i1 %bounds.cmp5, label %bounds.ok6, label %bounds.fail7

bounds.ok6:                                       ; preds = %bounds.ok
  %10 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 2]
  %.ptr8 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %11 = getelementptr inbounds i32, i32* %.ptr8, i64 %indvars.iv668 ; [#uses = 1, type = i32*]
  %12 = load i32, i32* %11, align 4               ; [#uses = 2]
  %13 = icmp slt i32 %10, %12                     ; [#uses = 1]
  %b_arg.a_arg.i = select i1 %13, i32 %12, i32 %10 ; [#uses = 2]
  store i32 %b_arg.a_arg.i, i32* @_D6source4dMaxi, align 4
  %indvars.iv.next669 = add nuw nsw i64 %indvars.iv668, 1 ; [#uses = 2]
  %14 = load i32, i32* %n, align 4                ; [#uses = 1]
  %15 = sext i32 %14 to i64                       ; [#uses = 1]
  %16 = icmp slt i64 %indvars.iv.next669, %15     ; [#uses = 1]
  br i1 %16, label %forbody, label %endfor

bounds.fail7:                                     ; preds = %bounds.ok
  %17 = and i64 %indvars.iv668, 4294967295        ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 97, i64 %17, i64 %.len4) #2
  unreachable

bounds.fail:                                      ; preds = %forbody
  %18 = and i64 %indvars.iv668, 4294967295        ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 96, i64 %18, i64 %.len) #2
  unreachable

endfor:                                           ; preds = %bounds.ok6, %.endfor_crit_edge
  %19 = phi i32 [ %.pre, %.endfor_crit_edge ], [ %b_arg.a_arg.i, %bounds.ok6 ] ; [#uses = 1, type = i32]
  %20 = sext i32 %19 to i64                       ; [#uses = 2]
  %.gc_mem9 = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ab6__initZ to %object.TypeInfo*), i64 %20) #1 ; [#uses = 1]
  %.ptr10 = extractvalue { i64, i8* } %.gc_mem9, 1 ; [#uses = 1]
  store i64 %20, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8
  store i8* %.ptr10, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8
  %21 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 1]
  %22 = sext i32 %21 to i64                       ; [#uses = 2]
  %.gc_mem11 = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %22) #1 ; [#uses = 1]
  %.ptr12 = extractvalue { i64, i8* } %.gc_mem11, 1 ; [#uses = 1]
  store i64 %22, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 0), align 8
  store i8* %.ptr12, i8** bitcast (i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source6seqTmpAi, i64 0, i32 1) to i8**), align 8
  %23 = load i32, i32* %n, align 4                ; [#uses = 2]
  %24 = icmp sgt i32 %23, 0                       ; [#uses = 1]
  br i1 %24, label %forbody15, label %endfor17

forbody15:                                        ; preds = %endfor, %bounds.ok20
  %indvars.iv666 = phi i64 [ %indvars.iv.next667, %bounds.ok20 ], [ 0, %endfor ] ; [#uses = 4, type = i64]
  %.len18 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp19 = icmp ugt i64 %.len18, %indvars.iv666 ; [#uses = 1]
  br i1 %bounds.cmp19, label %bounds.ok20, label %bounds.fail21

bounds.ok20:                                      ; preds = %forbody15
  %.ptr22 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %25 = getelementptr inbounds i32, i32* %.ptr22, i64 %indvars.iv666 ; [#uses = 1, type = i32*]
  %26 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %25) #7 ; [#uses = 0]
  %indvars.iv.next667 = add nuw nsw i64 %indvars.iv666, 1 ; [#uses = 2]
  %27 = load i32, i32* %n, align 4                ; [#uses = 2]
  %28 = sext i32 %27 to i64                       ; [#uses = 1]
  %29 = icmp slt i64 %indvars.iv.next667, %28     ; [#uses = 1]
  br i1 %29, label %forbody15, label %endfor17

bounds.fail21:                                    ; preds = %forbody15
  %30 = and i64 %indvars.iv666, 4294967295        ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 103, i64 %30, i64 %.len18) #2
  unreachable

endfor17:                                         ; preds = %bounds.ok20, %endfor
  %.lcssa453 = phi i32 [ %23, %endfor ], [ %27, %bounds.ok20 ] ; [#uses = 4, type = i32]
  %31 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 5]
  %32 = icmp slt i32 %31, 2                       ; [#uses = 1]
  br i1 %32, label %_D6source9factorialFiZi.exit, label %else.i.preheader

else.i.preheader:                                 ; preds = %endfor17
  %33 = add i32 %31, -1                           ; [#uses = 3]
  %min.iters.check = icmp ult i32 %33, 8          ; [#uses = 1]
  br i1 %min.iters.check, label %else.i.preheader968, label %vector.ph

vector.ph:                                        ; preds = %else.i.preheader
  %n.vec = and i32 %33, -8                        ; [#uses = 3]
  %ind.end = sub i32 %31, %n.vec                  ; [#uses = 1]
  %.splatinsert = insertelement <4 x i32> undef, i32 %31, i32 0 ; [#uses = 1]
  %.splat = shufflevector <4 x i32> %.splatinsert, <4 x i32> undef, <4 x i32> zeroinitializer ; [#uses = 1]
  %induction = add <4 x i32> %.splat, <i32 0, i32 -1, i32 -2, i32 -3> ; [#uses = 2]
  %34 = add i32 %n.vec, -8                        ; [#uses = 2]
  %35 = lshr exact i32 %34, 3                     ; [#uses = 1]
  %36 = add nuw nsw i32 %35, 1                    ; [#uses = 2]
  %xtraiter1105 = and i32 %36, 3                  ; [#uses = 2]
  %37 = icmp ult i32 %34, 24                      ; [#uses = 1]
  br i1 %37, label %middle.block.unr-lcssa, label %vector.ph.new

vector.ph.new:                                    ; preds = %vector.ph
  %unroll_iter1109 = and i32 %36, 1073741820      ; [#uses = 1]
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph.new
  %vec.ind = phi <4 x i32> [ %induction, %vector.ph.new ], [ %vec.ind.next.3, %vector.body ] ; [#uses = 9, type = <4 x i32>]
  %vec.phi = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph.new ], [ %44, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi962 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph.new ], [ %45, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %niter1110 = phi i32 [ %unroll_iter1109, %vector.ph.new ], [ %niter1110.nsub.3, %vector.body ] ; [#uses = 1, type = i32]
  %step.add = add <4 x i32> %vec.ind, <i32 -4, i32 -4, i32 -4, i32 -4> ; [#uses = 1]
  %38 = mul <4 x i32> %vec.phi, %vec.ind          ; [#uses = 1]
  %39 = mul <4 x i32> %vec.phi962, %step.add      ; [#uses = 1]
  %vec.ind.next = add <4 x i32> %vec.ind, <i32 -8, i32 -8, i32 -8, i32 -8> ; [#uses = 1]
  %step.add.1 = add <4 x i32> %vec.ind, <i32 -12, i32 -12, i32 -12, i32 -12> ; [#uses = 1]
  %40 = mul <4 x i32> %38, %vec.ind.next          ; [#uses = 1]
  %41 = mul <4 x i32> %39, %step.add.1            ; [#uses = 1]
  %vec.ind.next.1 = add <4 x i32> %vec.ind, <i32 -16, i32 -16, i32 -16, i32 -16> ; [#uses = 1]
  %step.add.2 = add <4 x i32> %vec.ind, <i32 -20, i32 -20, i32 -20, i32 -20> ; [#uses = 1]
  %42 = mul <4 x i32> %40, %vec.ind.next.1        ; [#uses = 1]
  %43 = mul <4 x i32> %41, %step.add.2            ; [#uses = 1]
  %vec.ind.next.2 = add <4 x i32> %vec.ind, <i32 -24, i32 -24, i32 -24, i32 -24> ; [#uses = 1]
  %step.add.3 = add <4 x i32> %vec.ind, <i32 -28, i32 -28, i32 -28, i32 -28> ; [#uses = 1]
  %44 = mul <4 x i32> %42, %vec.ind.next.2        ; [#uses = 3]
  %45 = mul <4 x i32> %43, %step.add.3            ; [#uses = 3]
  %vec.ind.next.3 = add <4 x i32> %vec.ind, <i32 -32, i32 -32, i32 -32, i32 -32> ; [#uses = 2]
  %niter1110.nsub.3 = add i32 %niter1110, -4      ; [#uses = 2]
  %niter1110.ncmp.3 = icmp eq i32 %niter1110.nsub.3, 0 ; [#uses = 1]
  br i1 %niter1110.ncmp.3, label %middle.block.unr-lcssa, label %vector.body, !llvm.loop !11

middle.block.unr-lcssa:                           ; preds = %vector.body, %vector.ph
  %.lcssa1096.ph = phi <4 x i32> [ undef, %vector.ph ], [ %44, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %.lcssa1095.ph = phi <4 x i32> [ undef, %vector.ph ], [ %45, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.ind.unr = phi <4 x i32> [ %induction, %vector.ph ], [ %vec.ind.next.3, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi.unr = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph ], [ %44, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi962.unr = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %vector.ph ], [ %45, %vector.body ] ; [#uses = 1, type = <4 x i32>]
  %lcmp.mod1106.not = icmp eq i32 %xtraiter1105, 0 ; [#uses = 1]
  br i1 %lcmp.mod1106.not, label %middle.block, label %vector.body.epil

vector.body.epil:                                 ; preds = %middle.block.unr-lcssa, %vector.body.epil
  %vec.ind.epil = phi <4 x i32> [ %vec.ind.next.epil, %vector.body.epil ], [ %vec.ind.unr, %middle.block.unr-lcssa ] ; [#uses = 3, type = <4 x i32>]
  %vec.phi.epil = phi <4 x i32> [ %46, %vector.body.epil ], [ %vec.phi.unr, %middle.block.unr-lcssa ] ; [#uses = 1, type = <4 x i32>]
  %vec.phi962.epil = phi <4 x i32> [ %47, %vector.body.epil ], [ %vec.phi962.unr, %middle.block.unr-lcssa ] ; [#uses = 1, type = <4 x i32>]
  %epil.iter = phi i32 [ %epil.iter.sub, %vector.body.epil ], [ %xtraiter1105, %middle.block.unr-lcssa ] ; [#uses = 1, type = i32]
  %step.add.epil = add <4 x i32> %vec.ind.epil, <i32 -4, i32 -4, i32 -4, i32 -4> ; [#uses = 1]
  %46 = mul <4 x i32> %vec.phi.epil, %vec.ind.epil ; [#uses = 2]
  %47 = mul <4 x i32> %vec.phi962.epil, %step.add.epil ; [#uses = 2]
  %vec.ind.next.epil = add <4 x i32> %vec.ind.epil, <i32 -8, i32 -8, i32 -8, i32 -8> ; [#uses = 1]
  %epil.iter.sub = add i32 %epil.iter, -1         ; [#uses = 2]
  %epil.iter.cmp.not = icmp eq i32 %epil.iter.sub, 0 ; [#uses = 1]
  br i1 %epil.iter.cmp.not, label %middle.block, label %vector.body.epil, !llvm.loop !12

middle.block:                                     ; preds = %vector.body.epil, %middle.block.unr-lcssa
  %.lcssa1096 = phi <4 x i32> [ %.lcssa1096.ph, %middle.block.unr-lcssa ], [ %46, %vector.body.epil ] ; [#uses = 1, type = <4 x i32>]
  %.lcssa1095 = phi <4 x i32> [ %.lcssa1095.ph, %middle.block.unr-lcssa ], [ %47, %vector.body.epil ] ; [#uses = 1, type = <4 x i32>]
  %bin.rdx = mul <4 x i32> %.lcssa1095, %.lcssa1096 ; [#uses = 1]
  %48 = call i32 @llvm.experimental.vector.reduce.mul.v4i32(<4 x i32> %bin.rdx) ; [#uses = 2]
  %cmp.n = icmp eq i32 %33, %n.vec                ; [#uses = 1]
  br i1 %cmp.n, label %_D6source9factorialFiZi.exit, label %else.i.preheader968

else.i.preheader968:                              ; preds = %middle.block, %else.i.preheader
  %a_arg.tr5.i.ph = phi i32 [ %31, %else.i.preheader ], [ %ind.end, %middle.block ] ; [#uses = 1, type = i32]
  %accumulator.tr4.i.ph = phi i32 [ 1, %else.i.preheader ], [ %48, %middle.block ] ; [#uses = 1, type = i32]
  br label %else.i

else.i:                                           ; preds = %else.i.preheader968, %else.i
  %a_arg.tr5.i = phi i32 [ %49, %else.i ], [ %a_arg.tr5.i.ph, %else.i.preheader968 ] ; [#uses = 3, type = i32]
  %accumulator.tr4.i = phi i32 [ %50, %else.i ], [ %accumulator.tr4.i.ph, %else.i.preheader968 ] ; [#uses = 1, type = i32]
  %49 = add nsw i32 %a_arg.tr5.i, -1              ; [#uses = 1]
  %50 = mul i32 %accumulator.tr4.i, %a_arg.tr5.i  ; [#uses = 2]
  %51 = icmp slt i32 %a_arg.tr5.i, 3              ; [#uses = 1]
  br i1 %51, label %_D6source9factorialFiZi.exit, label %else.i, !llvm.loop !13

_D6source9factorialFiZi.exit:                     ; preds = %else.i, %middle.block, %endfor17
  %accumulator.tr.lcssa.i = phi i32 [ 1, %endfor17 ], [ %48, %middle.block ], [ %50, %else.i ] ; [#uses = 8, type = i32]
  %52 = mul i32 %accumulator.tr.lcssa.i, %.lcssa453 ; [#uses = 2]
  %53 = sext i32 %52 to i64                       ; [#uses = 2]
  %.gc_mem.i = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %53) #1 ; [#uses = 1]
  %.ptr.i = extractvalue { i64, i8* } %.gc_mem.i, 1 ; [#uses = 1]
  %54 = bitcast i8* %.ptr.i to i32*               ; [#uses = 1]
  %55 = sext i32 %.lcssa453 to i64                ; [#uses = 2]
  %.gc_mem1.i = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D12TypeInfo_AAi6__initZ to %object.TypeInfo*), i64 %55) #1 ; [#uses = 1]
  %.ptr2.i = extractvalue { i64, i8* } %.gc_mem1.i, 1 ; [#uses = 2]
  %56 = bitcast i8* %.ptr2.i to { i64, i32* }*    ; [#uses = 2]
  %57 = icmp sgt i32 %.lcssa453, 0                ; [#uses = 1]
  br i1 %57, label %forbody.preheader.i, label %_D6source7dim2arrFiiZAAi.exit

forbody.preheader.i:                              ; preds = %_D6source9factorialFiZi.exit
  %wide.trip.count.i = zext i32 %.lcssa453 to i64 ; [#uses = 1]
  br label %bounds.ok.i

bounds.ok.i:                                      ; preds = %bounds.ok4.i, %forbody.preheader.i
  %indvars.iv.i = phi i64 [ 0, %forbody.preheader.i ], [ %indvars.iv.next.i, %bounds.ok4.i ] ; [#uses = 4, type = i64]
  %58 = trunc i64 %indvars.iv.i to i32            ; [#uses = 1]
  %59 = mul i32 %accumulator.tr.lcssa.i, %58      ; [#uses = 2]
  %60 = sext i32 %59 to i64                       ; [#uses = 3]
  %indvars.iv.next.i = add nuw nsw i64 %indvars.iv.i, 1 ; [#uses = 3]
  %61 = trunc i64 %indvars.iv.next.i to i32       ; [#uses = 1]
  %62 = mul i32 %accumulator.tr.lcssa.i, %61      ; [#uses = 3]
  %63 = sext i32 %62 to i64                       ; [#uses = 2]
  %bounds.cmp.up.i = icmp ule i32 %62, %52        ; [#uses = 1]
  %bounds.cmp.lo.i = icmp uge i32 %62, %59        ; [#uses = 1]
  %64 = and i1 %bounds.cmp.up.i, %bounds.cmp.lo.i ; [#uses = 1]
  br i1 %64, label %bounds.ok4.i, label %bounds.fail5.i

bounds.ok4.i:                                     ; preds = %bounds.ok.i
  %lowerbound.i = getelementptr inbounds i32, i32* %54, i64 %60 ; [#uses = 1, type = i32*]
  %65 = sub nsw i64 %63, %60                      ; [#uses = 1]
  %66 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %56, i64 %indvars.iv.i, i32 0 ; [#uses = 1, type = i64*]
  store i64 %65, i64* %66, align 8
  %67 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %56, i64 %indvars.iv.i, i32 1 ; [#uses = 1, type = i32**]
  store i32* %lowerbound.i, i32** %67, align 8
  %exitcond.not.i = icmp eq i64 %indvars.iv.next.i, %wide.trip.count.i ; [#uses = 1]
  br i1 %exitcond.not.i, label %_D6source7dim2arrFiiZAAi.exit, label %bounds.ok.i

bounds.fail5.i:                                   ; preds = %bounds.ok.i
  call void @_d_arraybounds_slice({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 12, i64 %60, i64 %63, i64 %53) #2
  unreachable

_D6source7dim2arrFiiZAAi.exit:                    ; preds = %bounds.ok4.i, %_D6source9factorialFiZi.exit
  store i64 %55, i64* getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 0), align 8
  store i8* %.ptr2.i, i8** bitcast ({ i64, i32* }** getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 1) to i8**), align 8
  %68 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 6]
  %69 = sext i32 %68 to i64                       ; [#uses = 8]
  %.gc_mem25 = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ai6__initZ to %object.TypeInfo*), i64 %69) #1 ; [#uses = 1]
  %.ptr26 = extractvalue { i64, i8* } %.gc_mem25, 1 ; [#uses = 1]
  %70 = bitcast i8* %.ptr26 to i32*               ; [#uses = 6]
  %71 = insertvalue { i64, i32* } undef, i64 %69, 0 ; [#uses = 1]
  %72 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 6]
  %73 = sext i32 %72 to i64                       ; [#uses = 4]
  %.gc_mem27 = call { i64, i8* } @_d_newarrayT(%object.TypeInfo* bitcast (%object.TypeInfo_Array* @_D11TypeInfo_Ab6__initZ to %object.TypeInfo*), i64 %73) #1 ; [#uses = 1]
  %.ptr28 = extractvalue { i64, i8* } %.gc_mem27, 1 ; [#uses = 4]
  %74 = icmp sgt i32 %accumulator.tr.lcssa.i, 0   ; [#uses = 3]
  br i1 %74, label %forbody30.lr.ph, label %forcond84.preheader

forbody30.lr.ph:                                  ; preds = %_D6source7dim2arrFiiZAAi.exit
  %.not491 = icmp eq i32 %68, 0                   ; [#uses = 1]
  %75 = icmp ugt i64 %69, 1                       ; [#uses = 1]
  %umax663 = select i1 %75, i64 %69, i64 1        ; [#uses = 1]
  %wide.trip.count654 = zext i32 %68 to i64       ; [#uses = 1]
  br label %forbody30

forcond84.preheader:                              ; preds = %bounds.ok80, %_D6source7dim2arrFiiZAAi.exit
  %76 = load i32, i32* %n, align 4                ; [#uses = 2]
  %77 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 2]
  %78 = sub i32 %76, %77                          ; [#uses = 2]
  %79 = icmp sgt i32 %78, 0                       ; [#uses = 1]
  br i1 %79, label %forcond89.preheader.lr.ph, label %endfor87

forcond89.preheader.lr.ph:                        ; preds = %forcond84.preheader
  %.fca.1.insert237 = insertvalue { i64, i32* } %71, i32* %70, 1 ; [#uses = 2]
  %80 = zext i32 %68 to i64                       ; [#uses = 3]
  %wide.trip.count648 = zext i32 %accumulator.tr.lcssa.i to i64 ; [#uses = 1]
  br label %forcond89.preheader

forbody30:                                        ; preds = %bounds.ok80, %forbody30.lr.ph
  %k.0480 = phi i32 [ 0, %forbody30.lr.ph ], [ %138, %bounds.ok80 ] ; [#uses = 3, type = i32]
  %.ptr.i299 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 1]
  %.len.i = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* align 1 %.ptr.i299, i8 0, i64 %.len.i, i1 false)
  %81 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 2]
  %82 = icmp sgt i32 %81, 0                       ; [#uses = 1]
  br i1 %82, label %forbody.i, label %_D6source8sequenceFAiiZv.exit

forbody.i:                                        ; preds = %forbody30, %_D6source6unUsedFAbiZi.exit.i
  %indvars.iv652 = phi i64 [ %indvars.iv.next653, %_D6source6unUsedFAbiZi.exit.i ], [ 0, %forbody30 ] ; [#uses = 4, type = i64]
  %83 = phi i32 [ %97, %_D6source6unUsedFAbiZi.exit.i ], [ %81, %forbody30 ] ; [#uses = 1, type = i32]
  %t.014.i = phi i32 [ %99, %_D6source6unUsedFAbiZi.exit.i ], [ %k.0480, %forbody30 ] ; [#uses = 2, type = i32]
  %exitcond655.not = icmp eq i64 %indvars.iv652, %wide.trip.count654 ; [#uses = 1]
  br i1 %exitcond655.not, label %bounds.fail.i, label %bounds.ok.i300

bounds.ok.i300:                                   ; preds = %forbody.i
  %84 = getelementptr inbounds i32, i32* %70, i64 %indvars.iv652 ; [#uses = 1, type = i32*]
  %.unpack.i = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 2]
  %.unpack9.i = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 2]
  %85 = trunc i64 %.unpack.i to i32               ; [#uses = 1]
  %86 = icmp sgt i32 %85, 0                       ; [#uses = 1]
  br i1 %86, label %forbody.preheader.i.i, label %assertFailed.i.i

forbody.preheader.i.i:                            ; preds = %bounds.ok.i300
  %87 = trunc i64 %indvars.iv652 to i32           ; [#uses = 2]
  %88 = sub i32 %83, %87                          ; [#uses = 1]
  %89 = srem i32 %t.014.i, %88                    ; [#uses = 1]
  %wide.trip.count.i.i = and i64 %.unpack.i, 4294967295 ; [#uses = 1]
  br label %forbody.i.i

forbody.i.i:                                      ; preds = %forinc.i.i, %forbody.preheader.i.i
  %indvars.iv.i.i = phi i64 [ 0, %forbody.preheader.i.i ], [ %indvars.iv.next.i.i, %forinc.i.i ] ; [#uses = 4, type = i64]
  %idx.013.i.i = phi i32 [ %89, %forbody.preheader.i.i ], [ %idx.1.i.i, %forinc.i.i ] ; [#uses = 3, type = i32]
  %90 = getelementptr inbounds i8, i8* %.unpack9.i, i64 %indvars.iv.i.i ; [#uses = 1, type = i8*]
  %91 = load i8, i8* %90, align 1, !range !10     ; [#uses = 1]
  %.not.i.i = icmp eq i8 %91, 0                   ; [#uses = 1]
  br i1 %.not.i.i, label %if.i.i, label %forinc.i.i

if.i.i:                                           ; preds = %forbody.i.i
  %92 = add i32 %idx.013.i.i, -1                  ; [#uses = 1]
  %93 = icmp eq i32 %idx.013.i.i, 0               ; [#uses = 1]
  br i1 %93, label %_D6source6unUsedFAbiZi.exit.i, label %forinc.i.i

forinc.i.i:                                       ; preds = %if.i.i, %forbody.i.i
  %idx.1.i.i = phi i32 [ %92, %if.i.i ], [ %idx.013.i.i, %forbody.i.i ] ; [#uses = 1, type = i32]
  %indvars.iv.next.i.i = add nuw nsw i64 %indvars.iv.i.i, 1 ; [#uses = 2]
  %exitcond.not.i.i = icmp eq i64 %indvars.iv.next.i.i, %wide.trip.count.i.i ; [#uses = 1]
  br i1 %exitcond.not.i.i, label %assertFailed.i.i, label %forbody.i.i

assertFailed.i.i:                                 ; preds = %bounds.ok.i300, %forinc.i.i
  call void @_d_assert({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 33) #2
  unreachable

_D6source6unUsedFAbiZi.exit.i:                    ; preds = %if.i.i
  %94 = trunc i64 %indvars.iv.i.i to i32          ; [#uses = 1]
  %95 = and i64 %indvars.iv.i.i, 4294967295       ; [#uses = 1]
  %96 = getelementptr inbounds i8, i8* %.unpack9.i, i64 %95 ; [#uses = 1, type = i8*]
  store i8 1, i8* %96, align 1
  store i32 %94, i32* %84, align 4
  %97 = load i32, i32* @_D6source4dMaxi, align 4  ; [#uses = 3]
  %98 = sub i32 %97, %87                          ; [#uses = 1]
  %99 = sdiv i32 %t.014.i, %98                    ; [#uses = 1]
  %indvars.iv.next653 = add nuw nsw i64 %indvars.iv652, 1 ; [#uses = 2]
  %100 = sext i32 %97 to i64                      ; [#uses = 1]
  %101 = icmp slt i64 %indvars.iv.next653, %100   ; [#uses = 1]
  br i1 %101, label %forbody.i, label %_D6source8sequenceFAiiZv.exit

bounds.fail.i:                                    ; preds = %forbody.i
  %wide.trip.count654.le = zext i32 %68 to i64    ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 42, i64 %wide.trip.count654.le, i64 %69) #2
  unreachable

_D6source8sequenceFAiiZv.exit:                    ; preds = %_D6source6unUsedFAbiZi.exit.i, %forbody30
  call void @llvm.memset.p0i8.i64(i8* align 1 %.ptr28, i8 0, i64 %73, i1 false)
  br i1 %.not491, label %endfor40, label %forbody38

forbody38:                                        ; preds = %_D6source8sequenceFAiiZv.exit, %forinc39
  %sum.0478 = phi i32 [ %sum.1.lcssa, %forinc39 ], [ 0, %_D6source8sequenceFAiiZv.exit ] ; [#uses = 3, type = i32]
  %__key110.0477 = phi i64 [ %133, %forinc39 ], [ 0, %_D6source8sequenceFAiiZv.exit ] ; [#uses = 2, type = i64]
  %102 = getelementptr inbounds i32, i32* %70, i64 %__key110.0477 ; [#uses = 1, type = i32*]
  %103 = load i32, i32* %102, align 4             ; [#uses = 7]
  %104 = sext i32 %103 to i64                     ; [#uses = 5]
  %bounds.cmp45 = icmp ult i32 %103, %72          ; [#uses = 1]
  br i1 %bounds.cmp45, label %bounds.ok46, label %bounds.fail47

bounds.ok46:                                      ; preds = %forbody38
  %105 = getelementptr inbounds i8, i8* %.ptr28, i64 %104 ; [#uses = 1, type = i8*]
  store i8 1, i8* %105, align 1
  %.len49 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp50 = icmp ugt i64 %.len49, %104      ; [#uses = 1]
  br i1 %bounds.cmp50, label %bounds.ok51, label %bounds.fail52

bounds.ok51:                                      ; preds = %bounds.ok46
  %.ptr53 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %106 = getelementptr inbounds i32, i32* %.ptr53, i64 %104 ; [#uses = 1, type = i32*]
  %107 = load i32, i32* %106, align 4             ; [#uses = 2]
  %108 = sub i32 %103, %107                       ; [#uses = 2]
  %109 = icmp sgt i32 %108, 0                     ; [#uses = 1]
  %b_arg.a_arg.i301 = select i1 %109, i32 %108, i32 0 ; [#uses = 7]
  %110 = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 2]
  %111 = add nuw i32 %103, 1                      ; [#uses = 1]
  %112 = add i32 %111, %107                       ; [#uses = 2]
  %113 = icmp slt i32 %112, %110                  ; [#uses = 1]
  %b_arg.a_arg.i302473 = select i1 %113, i32 %112, i32 %110 ; [#uses = 3]
  %114 = icmp slt i32 %b_arg.a_arg.i301, %b_arg.a_arg.i302473 ; [#uses = 1]
  br i1 %114, label %forbody55.lr.ph, label %forinc39

forbody55.lr.ph:                                  ; preds = %bounds.ok51
  %.len68 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp69 = icmp ugt i64 %.len68, %104      ; [#uses = 1]
  %.ptr72 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %115 = getelementptr inbounds i32, i32* %.ptr72, i64 %104 ; [#uses = 1, type = i32*]
  br i1 %bounds.cmp69, label %forbody55.us.preheader, label %forbody55.preheader

forbody55.preheader:                              ; preds = %forbody55.lr.ph
  %116 = icmp ugt i32 %72, %b_arg.a_arg.i301      ; [#uses = 1]
  %umax = select i1 %116, i32 %72, i32 %b_arg.a_arg.i301 ; [#uses = 1]
  br label %forbody55

forbody55.us.preheader:                           ; preds = %forbody55.lr.ph
  %117 = zext i32 %b_arg.a_arg.i301 to i64        ; [#uses = 1]
  %118 = sext i32 %b_arg.a_arg.i302473 to i64     ; [#uses = 1]
  %119 = icmp ugt i32 %72, %b_arg.a_arg.i301      ; [#uses = 1]
  %umax659 = select i1 %119, i32 %72, i32 %b_arg.a_arg.i301 ; [#uses = 2]
  %wide.trip.count661 = zext i32 %umax659 to i64  ; [#uses = 1]
  br label %forbody55.us

forbody55.us:                                     ; preds = %forbody55.us.preheader, %forinc56.us
  %indvars.iv657 = phi i64 [ %117, %forbody55.us.preheader ], [ %indvars.iv.next658, %forinc56.us ] ; [#uses = 3, type = i64]
  %sum.1475.us = phi i32 [ %sum.0478, %forbody55.us.preheader ], [ %sum.2.us, %forinc56.us ] ; [#uses = 2, type = i32]
  %exitcond662.not = icmp eq i64 %indvars.iv657, %wide.trip.count661 ; [#uses = 1]
  br i1 %exitcond662.not, label %bounds.fail66.loopexit, label %bounds.ok65.us

bounds.ok65.us:                                   ; preds = %forbody55.us
  %120 = getelementptr inbounds i8, i8* %.ptr28, i64 %indvars.iv657 ; [#uses = 1, type = i8*]
  %121 = load i8, i8* %120, align 1, !range !10   ; [#uses = 1]
  %.not295.us = icmp eq i8 %121, 0                ; [#uses = 1]
  br i1 %.not295.us, label %bounds.ok70.us, label %forinc56.us

bounds.ok70.us:                                   ; preds = %bounds.ok65.us
  %122 = load i32, i32* %115, align 4             ; [#uses = 1]
  %123 = add i32 %122, %sum.1475.us               ; [#uses = 1]
  br label %forinc56.us

forinc56.us:                                      ; preds = %bounds.ok70.us, %bounds.ok65.us
  %sum.2.us = phi i32 [ %123, %bounds.ok70.us ], [ %sum.1475.us, %bounds.ok65.us ] ; [#uses = 2, type = i32]
  %indvars.iv.next658 = add nuw nsw i64 %indvars.iv657, 1 ; [#uses = 2]
  %124 = icmp slt i64 %indvars.iv.next658, %118   ; [#uses = 1]
  br i1 %124, label %forbody55.us, label %forinc39

forbody55:                                        ; preds = %forbody55.preheader, %forinc56
  %j.0474 = phi i32 [ %129, %forinc56 ], [ %b_arg.a_arg.i301, %forbody55.preheader ] ; [#uses = 3, type = i32]
  %125 = sext i32 %j.0474 to i64                  ; [#uses = 2]
  %exitcond656.not = icmp eq i32 %j.0474, %umax   ; [#uses = 1]
  br i1 %exitcond656.not, label %bounds.fail66, label %bounds.ok65

bounds.ok65:                                      ; preds = %forbody55
  %126 = getelementptr inbounds i8, i8* %.ptr28, i64 %125 ; [#uses = 1, type = i8*]
  %127 = load i8, i8* %126, align 1, !range !10   ; [#uses = 1]
  %.not295 = icmp eq i8 %127, 0                   ; [#uses = 1]
  br i1 %.not295, label %bounds.fail71.us-lcssa, label %forinc56

bounds.fail71.us-lcssa:                           ; preds = %bounds.ok65
  %128 = sext i32 %103 to i64                     ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 123, i64 %128, i64 %.len68) #2
  unreachable

bounds.fail66.loopexit:                           ; preds = %forbody55.us
  %wide.trip.count661.le = zext i32 %umax659 to i64 ; [#uses = 1]
  br label %bounds.fail66

bounds.fail66:                                    ; preds = %forbody55, %bounds.fail66.loopexit
  %.lcssa435 = phi i64 [ %wide.trip.count661.le, %bounds.fail66.loopexit ], [ %125, %forbody55 ] ; [#uses = 1, type = i64]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 122, i64 %.lcssa435, i64 %73) #2
  unreachable

forinc56:                                         ; preds = %bounds.ok65
  %129 = add i32 %j.0474, 1                       ; [#uses = 2]
  %130 = icmp slt i32 %129, %b_arg.a_arg.i302473  ; [#uses = 1]
  br i1 %130, label %forbody55, label %forinc39

bounds.fail52:                                    ; preds = %bounds.ok46
  %131 = sext i32 %103 to i64                     ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 121, i64 %131, i64 %.len49) #2
  unreachable

bounds.fail47:                                    ; preds = %forbody38
  %132 = sext i32 %103 to i64                     ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 120, i64 %132, i64 %73) #2
  unreachable

forinc39:                                         ; preds = %forinc56, %forinc56.us, %bounds.ok51
  %sum.1.lcssa = phi i32 [ %sum.0478, %bounds.ok51 ], [ %sum.2.us, %forinc56.us ], [ %sum.0478, %forinc56 ] ; [#uses = 2, type = i32]
  %133 = add nuw i64 %__key110.0477, 1            ; [#uses = 2]
  %exitcond664.not = icmp eq i64 %133, %umax663   ; [#uses = 1]
  br i1 %exitcond664.not, label %endfor40, label %forbody38

endfor40:                                         ; preds = %forinc39, %_D6source8sequenceFAiiZv.exit
  %sum.0.lcssa = phi i32 [ 0, %_D6source8sequenceFAiiZv.exit ], [ %sum.1.lcssa, %forinc39 ] ; [#uses = 1, type = i32]
  %.len73 = load i64, i64* getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 0), align 8 ; [#uses = 1]
  %bounds.cmp74.not = icmp eq i64 %.len73, 0      ; [#uses = 1]
  br i1 %bounds.cmp74.not, label %bounds.fail76, label %bounds.ok75

bounds.ok75:                                      ; preds = %endfor40
  %.ptr77 = load { i64, i32* }*, { i64, i32* }** getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 1), align 8 ; [#uses = 2]
  %134 = sext i32 %k.0480 to i64                  ; [#uses = 3]
  %135 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr77, i64 0, i32 0 ; [#uses = 1, type = i64*]
  %.len78 = load i64, i64* %135, align 8          ; [#uses = 2]
  %bounds.cmp79 = icmp ugt i64 %.len78, %134      ; [#uses = 1]
  br i1 %bounds.cmp79, label %bounds.ok80, label %bounds.fail81

bounds.ok80:                                      ; preds = %bounds.ok75
  %136 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr77, i64 0, i32 1 ; [#uses = 1, type = i32**]
  %.ptr82 = load i32*, i32** %136, align 8        ; [#uses = 1]
  %137 = getelementptr inbounds i32, i32* %.ptr82, i64 %134 ; [#uses = 1, type = i32*]
  store i32 %sum.0.lcssa, i32* %137, align 4
  %138 = add nuw i32 %k.0480, 1                   ; [#uses = 2]
  %exitcond665.not = icmp eq i32 %138, %accumulator.tr.lcssa.i ; [#uses = 1]
  br i1 %exitcond665.not, label %forcond84.preheader, label %forbody30

bounds.fail81:                                    ; preds = %bounds.ok75
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 126, i64 %134, i64 %.len78) #2
  unreachable

bounds.fail76:                                    ; preds = %endfor40
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 126, i64 0, i64 0) #2
  unreachable

forcond89.preheader:                              ; preds = %forcond89.preheader.lr.ph, %forinc86
  %139 = phi i32 [ %77, %forcond89.preheader.lr.ph ], [ %231, %forinc86 ] ; [#uses = 3, type = i32]
  %140 = phi i32 [ %76, %forcond89.preheader.lr.ph ], [ %232, %forinc86 ] ; [#uses = 1, type = i32]
  %indvars.iv650 = phi i64 [ 0, %forcond89.preheader.lr.ph ], [ %141, %forinc86 ] ; [#uses = 7, type = i64]
  %141 = add nuw nsw i64 %indvars.iv650, 1        ; [#uses = 6]
  br i1 %74, label %forcond94.preheader.lr.ph, label %forinc86

forcond94.preheader.lr.ph:                        ; preds = %forcond89.preheader
  %142 = trunc i64 %indvars.iv650 to i32          ; [#uses = 1]
  %143 = trunc i64 %indvars.iv650 to i32          ; [#uses = 1]
  br label %forcond94.preheader

forcond94.preheader:                              ; preds = %forinc91, %forcond94.preheader.lr.ph
  %144 = phi i32 [ %139, %forcond94.preheader.lr.ph ], [ %229, %forinc91 ] ; [#uses = 1, type = i32]
  %145 = phi i32 [ %139, %forcond94.preheader.lr.ph ], [ %230, %forinc91 ] ; [#uses = 2, type = i32]
  %indvars.iv646 = phi i64 [ 0, %forcond94.preheader.lr.ph ], [ %indvars.iv.next647, %forinc91 ] ; [#uses = 5, type = i64]
  %146 = add i32 %145, 1                          ; [#uses = 1]
  %147 = icmp sgt i32 %146, 0                     ; [#uses = 1]
  br i1 %147, label %forbody95.lr.ph, label %forinc91

forbody95.lr.ph:                                  ; preds = %forcond94.preheader
  %148 = trunc i64 %indvars.iv646 to i32          ; [#uses = 1]
  br label %forbody95

forbody95:                                        ; preds = %forbody95.lr.ph, %bounds.ok162
  %indvars.iv642 = phi i64 [ 0, %forbody95.lr.ph ], [ %indvars.iv.next643, %bounds.ok162 ] ; [#uses = 2, type = i64]
  %indvars.iv639 = phi i64 [ 0, %forbody95.lr.ph ], [ %indvars.iv.next640, %bounds.ok162 ] ; [#uses = 11, type = i64]
  %149 = xor i64 %indvars.iv639, -1               ; [#uses = 1]
  %.len98 = load i64, i64* getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp99 = icmp ugt i64 %.len98, %indvars.iv650 ; [#uses = 1]
  br i1 %bounds.cmp99, label %bounds.ok100, label %bounds.fail101

bounds.ok100:                                     ; preds = %forbody95
  %.ptr102 = load { i64, i32* }*, { i64, i32* }** getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 1), align 8 ; [#uses = 2]
  %150 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr102, i64 %indvars.iv650, i32 0 ; [#uses = 1, type = i64*]
  %.len103 = load i64, i64* %150, align 8         ; [#uses = 2]
  %bounds.cmp104 = icmp ugt i64 %.len103, %indvars.iv646 ; [#uses = 1]
  br i1 %bounds.cmp104, label %bounds.ok105, label %bounds.fail106

bounds.ok105:                                     ; preds = %bounds.ok100
  %151 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr102, i64 %indvars.iv650, i32 1 ; [#uses = 1, type = i32**]
  %.ptr107 = load i32*, i32** %151, align 8       ; [#uses = 1]
  %152 = getelementptr inbounds i32, i32* %.ptr107, i64 %indvars.iv646 ; [#uses = 1, type = i32*]
  %153 = load i32, i32* %152, align 4             ; [#uses = 2]
  %.ptr.i303 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 1]
  %.len.i304 = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* align 1 %.ptr.i303, i8 0, i64 %.len.i304, i1 false)
  %154 = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 3]
  %155 = icmp sgt i32 %154, 0                     ; [#uses = 1]
  br i1 %155, label %forbody.i308, label %_D6source8sequenceFAiiZv.exit326

forbody.i308:                                     ; preds = %bounds.ok105, %_D6source6unUsedFAbiZi.exit.i324
  %indvars.iv635 = phi i64 [ %indvars.iv.next636, %_D6source6unUsedFAbiZi.exit.i324 ], [ 0, %bounds.ok105 ] ; [#uses = 4, type = i64]
  %156 = phi i32 [ %170, %_D6source6unUsedFAbiZi.exit.i324 ], [ %154, %bounds.ok105 ] ; [#uses = 1, type = i32]
  %t.014.i306 = phi i32 [ %172, %_D6source6unUsedFAbiZi.exit.i324 ], [ %148, %bounds.ok105 ] ; [#uses = 2, type = i32]
  %exitcond638.not = icmp eq i64 %indvars.iv635, %80 ; [#uses = 1]
  br i1 %exitcond638.not, label %bounds.fail.i325, label %bounds.ok.i311

bounds.ok.i311:                                   ; preds = %forbody.i308
  %157 = getelementptr inbounds i32, i32* %70, i64 %indvars.iv635 ; [#uses = 1, type = i32*]
  %.unpack.i309 = load i64, i64* getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 0), align 8 ; [#uses = 2]
  %.unpack9.i310 = load i8*, i8** getelementptr inbounds ({ i64, i8* }, { i64, i8* }* @_D6source4usedAb, i64 0, i32 1), align 8 ; [#uses = 2]
  %158 = trunc i64 %.unpack.i309 to i32           ; [#uses = 1]
  %159 = icmp sgt i32 %158, 0                     ; [#uses = 1]
  br i1 %159, label %forbody.preheader.i.i313, label %assertFailed.i.i323

forbody.preheader.i.i313:                         ; preds = %bounds.ok.i311
  %160 = trunc i64 %indvars.iv635 to i32          ; [#uses = 2]
  %161 = sub i32 %156, %160                       ; [#uses = 1]
  %162 = srem i32 %t.014.i306, %161               ; [#uses = 1]
  %wide.trip.count.i.i312 = and i64 %.unpack.i309, 4294967295 ; [#uses = 1]
  br label %forbody.i.i317

forbody.i.i317:                                   ; preds = %forinc.i.i322, %forbody.preheader.i.i313
  %indvars.iv.i.i314 = phi i64 [ 0, %forbody.preheader.i.i313 ], [ %indvars.iv.next.i.i320, %forinc.i.i322 ] ; [#uses = 4, type = i64]
  %idx.013.i.i315 = phi i32 [ %162, %forbody.preheader.i.i313 ], [ %idx.1.i.i319, %forinc.i.i322 ] ; [#uses = 3, type = i32]
  %163 = getelementptr inbounds i8, i8* %.unpack9.i310, i64 %indvars.iv.i.i314 ; [#uses = 1, type = i8*]
  %164 = load i8, i8* %163, align 1, !range !10   ; [#uses = 1]
  %.not.i.i316 = icmp eq i8 %164, 0               ; [#uses = 1]
  br i1 %.not.i.i316, label %if.i.i318, label %forinc.i.i322

if.i.i318:                                        ; preds = %forbody.i.i317
  %165 = add i32 %idx.013.i.i315, -1              ; [#uses = 1]
  %166 = icmp eq i32 %idx.013.i.i315, 0           ; [#uses = 1]
  br i1 %166, label %_D6source6unUsedFAbiZi.exit.i324, label %forinc.i.i322

forinc.i.i322:                                    ; preds = %if.i.i318, %forbody.i.i317
  %idx.1.i.i319 = phi i32 [ %165, %if.i.i318 ], [ %idx.013.i.i315, %forbody.i.i317 ] ; [#uses = 1, type = i32]
  %indvars.iv.next.i.i320 = add nuw nsw i64 %indvars.iv.i.i314, 1 ; [#uses = 2]
  %exitcond.not.i.i321 = icmp eq i64 %indvars.iv.next.i.i320, %wide.trip.count.i.i312 ; [#uses = 1]
  br i1 %exitcond.not.i.i321, label %assertFailed.i.i323, label %forbody.i.i317

assertFailed.i.i323:                              ; preds = %bounds.ok.i311, %forinc.i.i322
  call void @_d_assert({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 33) #2
  unreachable

_D6source6unUsedFAbiZi.exit.i324:                 ; preds = %if.i.i318
  %167 = trunc i64 %indvars.iv.i.i314 to i32      ; [#uses = 1]
  %168 = and i64 %indvars.iv.i.i314, 4294967295   ; [#uses = 1]
  %169 = getelementptr inbounds i8, i8* %.unpack9.i310, i64 %168 ; [#uses = 1, type = i8*]
  store i8 1, i8* %169, align 1
  store i32 %167, i32* %157, align 4
  %170 = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 4]
  %171 = sub i32 %170, %160                       ; [#uses = 1]
  %172 = sdiv i32 %t.014.i306, %171               ; [#uses = 1]
  %indvars.iv.next636 = add nuw nsw i64 %indvars.iv635, 1 ; [#uses = 2]
  %173 = sext i32 %170 to i64                     ; [#uses = 1]
  %174 = icmp slt i64 %indvars.iv.next636, %173   ; [#uses = 1]
  br i1 %174, label %forbody.i308, label %_D6source8sequenceFAiiZv.exit326

bounds.fail.i325:                                 ; preds = %forbody.i308
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 42, i64 %80, i64 %69) #2
  unreachable

_D6source8sequenceFAiiZv.exit326:                 ; preds = %_D6source6unUsedFAbiZi.exit.i324, %bounds.ok105
  %175 = phi i32 [ %154, %bounds.ok105 ], [ %170, %_D6source6unUsedFAbiZi.exit.i324 ] ; [#uses = 10, type = i32]
  %bounds.cmp.up.not = icmp ugt i64 %indvars.iv639, %80 ; [#uses = 1]
  br i1 %bounds.cmp.up.not, label %bounds.fail109, label %forcond112.preheader

forcond112.preheader:                             ; preds = %_D6source8sequenceFAiiZv.exit326
  %.not = icmp eq i64 %indvars.iv639, 0           ; [#uses = 1]
  br i1 %.not, label %endfor115, label %forbody113.lr.ph

forbody113.lr.ph:                                 ; preds = %forcond112.preheader
  %.len118 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %.ptr122 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %.len125 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %.ptr129 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 1), align 8 ; [#uses = 1]
  br label %forbody113

forbody113:                                       ; preds = %forinc114, %forbody113.lr.ph
  %__key112.0462 = phi i64 [ 0, %forbody113.lr.ph ], [ %186, %forinc114 ] ; [#uses = 2, type = i64]
  %s.0461 = phi i32 [ %153, %forbody113.lr.ph ], [ %s.1, %forinc114 ] ; [#uses = 2, type = i32]
  %176 = getelementptr inbounds i32, i32* %70, i64 %__key112.0462 ; [#uses = 1, type = i32*]
  %177 = load i32, i32* %176, align 4             ; [#uses = 2]
  %178 = add i32 %177, %142                       ; [#uses = 1]
  %179 = sext i32 %178 to i64                     ; [#uses = 6]
  %bounds.cmp119 = icmp ugt i64 %.len118, %179    ; [#uses = 1]
  br i1 %bounds.cmp119, label %bounds.ok120, label %bounds.fail121

bounds.ok120:                                     ; preds = %forbody113
  %180 = sub i32 %175, %177                       ; [#uses = 1]
  %181 = getelementptr inbounds i32, i32* %.ptr122, i64 %179 ; [#uses = 1, type = i32*]
  %182 = load i32, i32* %181, align 4             ; [#uses = 1]
  %.not294 = icmp sgt i32 %180, %182              ; [#uses = 1]
  br i1 %.not294, label %forinc114, label %if123

if123:                                            ; preds = %bounds.ok120
  %bounds.cmp126 = icmp ugt i64 %.len125, %179    ; [#uses = 1]
  br i1 %bounds.cmp126, label %bounds.ok127, label %bounds.fail128

bounds.ok127:                                     ; preds = %if123
  %183 = getelementptr inbounds i32, i32* %.ptr129, i64 %179 ; [#uses = 1, type = i32*]
  %184 = load i32, i32* %183, align 4             ; [#uses = 1]
  %185 = add i32 %184, %s.0461                    ; [#uses = 1]
  br label %forinc114

bounds.fail128:                                   ; preds = %if123
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 137, i64 %179, i64 %.len125) #2
  unreachable

bounds.fail121:                                   ; preds = %forbody113
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 136, i64 %179, i64 %.len118) #2
  unreachable

forinc114:                                        ; preds = %bounds.ok120, %bounds.ok127
  %s.1 = phi i32 [ %185, %bounds.ok127 ], [ %s.0461, %bounds.ok120 ] ; [#uses = 2, type = i32]
  %186 = add nuw nsw i64 %__key112.0462, 1        ; [#uses = 2]
  %exitcond641.not = icmp eq i64 %186, %indvars.iv639 ; [#uses = 1]
  br i1 %exitcond641.not, label %endfor115, label %forbody113

endfor115:                                        ; preds = %forinc114, %forcond112.preheader
  %s.0.lcssa = phi i32 [ %153, %forcond112.preheader ], [ %s.1, %forinc114 ] ; [#uses = 4, type = i32]
  %bounds.cmp.up133 = icmp ule i32 %175, %68      ; [#uses = 1]
  %187 = zext i32 %175 to i64                     ; [#uses = 1]
  %bounds.cmp.lo = icmp ule i64 %indvars.iv639, %187 ; [#uses = 1]
  %188 = and i1 %bounds.cmp.up133, %bounds.cmp.lo ; [#uses = 1]
  %189 = sext i32 %175 to i64                     ; [#uses = 4]
  br i1 %188, label %bounds.ok130, label %bounds.fail131

bounds.ok130:                                     ; preds = %endfor115
  %lowerbound135 = getelementptr inbounds i32, i32* %70, i64 %indvars.iv639 ; [#uses = 4, type = i32*]
  %.not490 = icmp eq i64 %indvars.iv639, %189     ; [#uses = 1]
  br i1 %.not490, label %endfor139, label %forbody137.lr.ph

forbody137.lr.ph:                                 ; preds = %bounds.ok130
  %190 = add i32 %175, %143                       ; [#uses = 1]
  %191 = sext i32 %190 to i64                     ; [#uses = 6]
  %.len143 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp144 = icmp ugt i64 %.len143, %191    ; [#uses = 1]
  %.len150 = load i64, i64* getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %.ptr154 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2asAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %192 = getelementptr inbounds i32, i32* %.ptr154, i64 %191 ; [#uses = 3, type = i32*]
  br i1 %bounds.cmp144, label %forbody137.lr.ph.split.us, label %bounds.fail146

forbody137.lr.ph.split.us:                        ; preds = %forbody137.lr.ph
  %bounds.cmp151 = icmp ugt i64 %.len150, %191    ; [#uses = 1]
  %.ptr147 = load i32*, i32** getelementptr inbounds ({ i64, i32* }, { i64, i32* }* @_D6source2dsAi, i64 0, i32 1), align 8 ; [#uses = 1]
  %193 = getelementptr inbounds i32, i32* %.ptr147, i64 %191 ; [#uses = 1, type = i32*]
  %194 = load i32, i32* %193, align 4             ; [#uses = 4]
  %195 = add i64 %indvars.iv642, %189             ; [#uses = 3]
  br i1 %bounds.cmp151, label %forbody137.us.us.preheader, label %forbody137.us

forbody137.us.us.preheader:                       ; preds = %forbody137.lr.ph.split.us
  %xtraiter = and i64 %195, 1                     ; [#uses = 1]
  %196 = sub nsw i64 0, %189                      ; [#uses = 1]
  %197 = icmp eq i64 %149, %196                   ; [#uses = 1]
  br i1 %197, label %endfor139.loopexit.unr-lcssa, label %forbody137.us.us.preheader.new

forbody137.us.us.preheader.new:                   ; preds = %forbody137.us.us.preheader
  %unroll_iter = and i64 %195, -2                 ; [#uses = 1]
  br label %forbody137.us.us

forbody137.us.us:                                 ; preds = %forinc138.us.us.1, %forbody137.us.us.preheader.new
  %__key114.0465.us.us = phi i64 [ 0, %forbody137.us.us.preheader.new ], [ %249, %forinc138.us.us.1 ] ; [#uses = 3, type = i64]
  %s.2464.us.us = phi i32 [ %s.0.lcssa, %forbody137.us.us.preheader.new ], [ %s.3.us.us.1, %forinc138.us.us.1 ] ; [#uses = 2, type = i32]
  %niter = phi i64 [ %unroll_iter, %forbody137.us.us.preheader.new ], [ %niter.nsub.1, %forinc138.us.us.1 ] ; [#uses = 1, type = i64]
  %198 = getelementptr inbounds i32, i32* %lowerbound135, i64 %__key114.0465.us.us ; [#uses = 1, type = i32*]
  %199 = load i32, i32* %198, align 4             ; [#uses = 1]
  %200 = sub i32 %175, %199                       ; [#uses = 1]
  %.not.us.us = icmp sgt i32 %200, %194           ; [#uses = 1]
  br i1 %.not.us.us, label %forinc138.us.us, label %bounds.ok152.us.us

bounds.ok152.us.us:                               ; preds = %forbody137.us.us
  %201 = load i32, i32* %192, align 4             ; [#uses = 1]
  %202 = add i32 %201, %s.2464.us.us              ; [#uses = 1]
  br label %forinc138.us.us

forinc138.us.us:                                  ; preds = %bounds.ok152.us.us, %forbody137.us.us
  %s.3.us.us = phi i32 [ %202, %bounds.ok152.us.us ], [ %s.2464.us.us, %forbody137.us.us ] ; [#uses = 2, type = i32]
  %203 = or i64 %__key114.0465.us.us, 1           ; [#uses = 1]
  %204 = getelementptr inbounds i32, i32* %lowerbound135, i64 %203 ; [#uses = 1, type = i32*]
  %205 = load i32, i32* %204, align 4             ; [#uses = 1]
  %206 = sub i32 %175, %205                       ; [#uses = 1]
  %.not.us.us.1 = icmp sgt i32 %206, %194         ; [#uses = 1]
  br i1 %.not.us.us.1, label %forinc138.us.us.1, label %bounds.ok152.us.us.1

forbody137.us:                                    ; preds = %forbody137.lr.ph.split.us, %forinc138.us
  %__key114.0465.us = phi i64 [ %210, %forinc138.us ], [ 0, %forbody137.lr.ph.split.us ] ; [#uses = 2, type = i64]
  %207 = getelementptr inbounds i32, i32* %lowerbound135, i64 %__key114.0465.us ; [#uses = 1, type = i32*]
  %208 = load i32, i32* %207, align 4             ; [#uses = 1]
  %209 = sub i32 %175, %208                       ; [#uses = 1]
  %.not.us = icmp sgt i32 %209, %194              ; [#uses = 1]
  br i1 %.not.us, label %forinc138.us, label %bounds.fail153

forinc138.us:                                     ; preds = %forbody137.us
  %210 = add nuw i64 %__key114.0465.us, 1         ; [#uses = 2]
  %exitcond644.not = icmp eq i64 %210, %195       ; [#uses = 1]
  br i1 %exitcond644.not, label %endfor139, label %forbody137.us

bounds.fail153:                                   ; preds = %forbody137.us
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 142, i64 %191, i64 %.len150) #2
  unreachable

bounds.fail146:                                   ; preds = %forbody137.lr.ph
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 141, i64 %191, i64 %.len143) #2
  unreachable

endfor139.loopexit.unr-lcssa:                     ; preds = %forinc138.us.us.1, %forbody137.us.us.preheader
  %s.3.us.us.lcssa.ph = phi i32 [ undef, %forbody137.us.us.preheader ], [ %s.3.us.us.1, %forinc138.us.us.1 ] ; [#uses = 1, type = i32]
  %__key114.0465.us.us.unr = phi i64 [ 0, %forbody137.us.us.preheader ], [ %249, %forinc138.us.us.1 ] ; [#uses = 1, type = i64]
  %s.2464.us.us.unr = phi i32 [ %s.0.lcssa, %forbody137.us.us.preheader ], [ %s.3.us.us.1, %forinc138.us.us.1 ] ; [#uses = 2, type = i32]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0        ; [#uses = 1]
  br i1 %lcmp.mod.not, label %endfor139, label %forbody137.us.us.epil

forbody137.us.us.epil:                            ; preds = %endfor139.loopexit.unr-lcssa
  %211 = getelementptr inbounds i32, i32* %lowerbound135, i64 %__key114.0465.us.us.unr ; [#uses = 1, type = i32*]
  %212 = load i32, i32* %211, align 4             ; [#uses = 1]
  %213 = sub i32 %175, %212                       ; [#uses = 1]
  %.not.us.us.epil = icmp sgt i32 %213, %194      ; [#uses = 1]
  br i1 %.not.us.us.epil, label %endfor139, label %bounds.ok152.us.us.epil

bounds.ok152.us.us.epil:                          ; preds = %forbody137.us.us.epil
  %214 = load i32, i32* %192, align 4             ; [#uses = 1]
  %215 = add i32 %214, %s.2464.us.us.unr          ; [#uses = 1]
  br label %endfor139

endfor139:                                        ; preds = %forinc138.us, %endfor139.loopexit.unr-lcssa, %forbody137.us.us.epil, %bounds.ok152.us.us.epil, %bounds.ok130
  %s.2.lcssa = phi i32 [ %s.0.lcssa, %bounds.ok130 ], [ %s.3.us.us.lcssa.ph, %endfor139.loopexit.unr-lcssa ], [ %215, %bounds.ok152.us.us.epil ], [ %s.2464.us.us.unr, %forbody137.us.us.epil ], [ %s.0.lcssa, %forinc138.us ] ; [#uses = 2, type = i32]
  %216 = add i32 %175, -1                         ; [#uses = 1]
  %217 = trunc i64 %indvars.iv639 to i32          ; [#uses = 1]
  call void @_D6source11step_insertFAiiiZv(i32 %217, i32 %216, { i64, i32* } %.fca.1.insert237) #0
  %218 = call i32 @_D6source6seqIdxFAiZi({ i64, i32* } %.fca.1.insert237) #0 ; [#uses = 1]
  %.len155 = load i64, i64* getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp156 = icmp ugt i64 %.len155, %141    ; [#uses = 1]
  br i1 %bounds.cmp156, label %bounds.ok157, label %bounds.fail158

bounds.ok157:                                     ; preds = %endfor139
  %.ptr159 = load { i64, i32* }*, { i64, i32* }** getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 1), align 8 ; [#uses = 2]
  %219 = sext i32 %218 to i64                     ; [#uses = 3]
  %220 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr159, i64 %141, i32 0 ; [#uses = 1, type = i64*]
  %.len160 = load i64, i64* %220, align 8         ; [#uses = 2]
  %bounds.cmp161 = icmp ugt i64 %.len160, %219    ; [#uses = 1]
  br i1 %bounds.cmp161, label %bounds.ok162, label %bounds.fail163

bounds.ok162:                                     ; preds = %bounds.ok157
  %221 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr159, i64 %141, i32 1 ; [#uses = 1, type = i32**]
  %.ptr164 = load i32*, i32** %221, align 8       ; [#uses = 1]
  %222 = getelementptr inbounds i32, i32* %.ptr164, i64 %219 ; [#uses = 2, type = i32*]
  %223 = load i32, i32* %222, align 4             ; [#uses = 2]
  %224 = icmp slt i32 %223, %s.2.lcssa            ; [#uses = 1]
  %b_arg.a_arg.i298 = select i1 %224, i32 %s.2.lcssa, i32 %223 ; [#uses = 1]
  store i32 %b_arg.a_arg.i298, i32* %222, align 4
  %indvars.iv.next640 = add nuw nsw i64 %indvars.iv639, 1 ; [#uses = 2]
  %225 = load i32, i32* @_D6source4dMaxi, align 4 ; [#uses = 3]
  %226 = add i32 %225, 1                          ; [#uses = 1]
  %227 = sext i32 %226 to i64                     ; [#uses = 1]
  %228 = icmp slt i64 %indvars.iv.next640, %227   ; [#uses = 1]
  %indvars.iv.next643 = add nsw i64 %indvars.iv642, -1 ; [#uses = 1]
  br i1 %228, label %forbody95, label %forinc91

bounds.fail163:                                   ; preds = %bounds.ok157
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 147, i64 %219, i64 %.len160) #2
  unreachable

bounds.fail158:                                   ; preds = %endfor139
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 147, i64 %141, i64 %.len155) #2
  unreachable

bounds.fail131:                                   ; preds = %endfor115
  call void @_d_arraybounds_slice({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 140, i64 %indvars.iv639, i64 %189, i64 %69) #2
  unreachable

bounds.fail109:                                   ; preds = %_D6source8sequenceFAiiZv.exit326
  call void @_d_arraybounds_slice({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 135, i64 0, i64 %indvars.iv639, i64 %69) #2
  unreachable

bounds.fail106:                                   ; preds = %bounds.ok100
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 132, i64 %indvars.iv646, i64 %.len103) #2
  unreachable

bounds.fail101:                                   ; preds = %forbody95
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 132, i64 %indvars.iv650, i64 %.len98) #2
  unreachable

forinc91:                                         ; preds = %bounds.ok162, %forcond94.preheader
  %229 = phi i32 [ %144, %forcond94.preheader ], [ %225, %bounds.ok162 ] ; [#uses = 2, type = i32]
  %230 = phi i32 [ %145, %forcond94.preheader ], [ %225, %bounds.ok162 ] ; [#uses = 1, type = i32]
  %indvars.iv.next647 = add nuw nsw i64 %indvars.iv646, 1 ; [#uses = 2]
  %exitcond649.not = icmp eq i64 %indvars.iv.next647, %wide.trip.count648 ; [#uses = 1]
  br i1 %exitcond649.not, label %forinc86.loopexit, label %forcond94.preheader

forinc86.loopexit:                                ; preds = %forinc91
  %.pre671 = load i32, i32* %n, align 4           ; [#uses = 1]
  br label %forinc86

forinc86:                                         ; preds = %forcond89.preheader, %forinc86.loopexit
  %231 = phi i32 [ %229, %forinc86.loopexit ], [ %139, %forcond89.preheader ] ; [#uses = 2, type = i32]
  %232 = phi i32 [ %.pre671, %forinc86.loopexit ], [ %140, %forcond89.preheader ] ; [#uses = 2, type = i32]
  %233 = sub i32 %232, %231                       ; [#uses = 2]
  %234 = sext i32 %233 to i64                     ; [#uses = 1]
  %235 = icmp slt i64 %141, %234                  ; [#uses = 1]
  br i1 %235, label %forcond89.preheader, label %endfor87

endfor87:                                         ; preds = %forinc86, %forcond84.preheader
  %.lcssa414 = phi i32 [ %78, %forcond84.preheader ], [ %233, %forinc86 ] ; [#uses = 2, type = i32]
  br i1 %74, label %forbody177.lr.ph, label %endfor179

forbody177.lr.ph:                                 ; preds = %endfor87
  %236 = icmp sgt i32 %.lcssa414, 0               ; [#uses = 1]
  %b_arg.a_arg.i297 = select i1 %236, i32 %.lcssa414, i32 0 ; [#uses = 1]
  %237 = zext i32 %b_arg.a_arg.i297 to i64        ; [#uses = 4]
  %.len180 = load i64, i64* getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 0), align 8 ; [#uses = 2]
  %bounds.cmp181 = icmp ugt i64 %.len180, %237    ; [#uses = 1]
  %.ptr184 = load { i64, i32* }*, { i64, i32* }** getelementptr inbounds ({ i64, { i64, i32* }* }, { i64, { i64, i32* }* }* @_D6source2dpAAi, i64 0, i32 1), align 8 ; [#uses = 2]
  %238 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr184, i64 %237, i32 1 ; [#uses = 1, type = i32**]
  br i1 %bounds.cmp181, label %forbody177.lr.ph.split.us, label %bounds.fail183

forbody177.lr.ph.split.us:                        ; preds = %forbody177.lr.ph
  %239 = getelementptr inbounds { i64, i32* }, { i64, i32* }* %.ptr184, i64 %237, i32 0 ; [#uses = 1, type = i64*]
  %.len185.us = load i64, i64* %239, align 8      ; [#uses = 4]
  %240 = add nsw i32 %accumulator.tr.lcssa.i, -1  ; [#uses = 1]
  %241 = zext i32 %240 to i64                     ; [#uses = 2]
  %wide.trip.count = zext i32 %accumulator.tr.lcssa.i to i64 ; [#uses = 1]
  br label %forbody177.us

forbody177.us:                                    ; preds = %bounds.ok187.us, %forbody177.lr.ph.split.us
  %indvars.iv = phi i64 [ %indvars.iv.next, %bounds.ok187.us ], [ 0, %forbody177.lr.ph.split.us ] ; [#uses = 3, type = i64]
  %ans.0459.us = phi i32 [ %b_arg.a_arg.i296.us, %bounds.ok187.us ], [ 0, %forbody177.lr.ph.split.us ] ; [#uses = 2, type = i32]
  %exitcond.not = icmp eq i64 %indvars.iv, %.len185.us ; [#uses = 1]
  br i1 %exitcond.not, label %bounds.fail188, label %bounds.ok187.us

bounds.ok187.us:                                  ; preds = %forbody177.us
  %.ptr189.us = load i32*, i32** %238, align 8    ; [#uses = 1]
  %242 = getelementptr inbounds i32, i32* %.ptr189.us, i64 %indvars.iv ; [#uses = 1, type = i32*]
  %243 = load i32, i32* %242, align 4             ; [#uses = 2]
  %244 = icmp slt i32 %243, %ans.0459.us          ; [#uses = 1]
  %b_arg.a_arg.i296.us = select i1 %244, i32 %ans.0459.us, i32 %243 ; [#uses = 2]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 ; [#uses = 2]
  %exitcond634.not = icmp eq i64 %indvars.iv.next, %wide.trip.count ; [#uses = 1]
  br i1 %exitcond634.not, label %endfor179, label %forbody177.us

bounds.fail188:                                   ; preds = %forbody177.us
  %245 = icmp ult i64 %.len185.us, %241           ; [#uses = 1]
  %umin = select i1 %245, i64 %.len185.us, i64 %241 ; [#uses = 1]
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 155, i64 %umin, i64 %.len185.us) #2
  unreachable

bounds.fail183:                                   ; preds = %forbody177.lr.ph
  call void @_d_arraybounds_index({ i64, i8* } { i64 61, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i32 0, i32 0) }, i32 155, i64 %237, i64 %.len180) #2
  unreachable

endfor179:                                        ; preds = %bounds.ok187.us, %endfor87
  %ans.0.lcssa = phi i32 [ 0, %endfor87 ], [ %b_arg.a_arg.i296.us, %bounds.ok187.us ] ; [#uses = 1, type = i32]
  %246 = call i32 (i8*, ...) @printf(i8* nonnull dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %ans.0.lcssa) #7 ; [#uses = 0]
  ret i32 0

bounds.ok152.us.us.1:                             ; preds = %forinc138.us.us
  %247 = load i32, i32* %192, align 4             ; [#uses = 1]
  %248 = add i32 %247, %s.3.us.us                 ; [#uses = 1]
  br label %forinc138.us.us.1

forinc138.us.us.1:                                ; preds = %bounds.ok152.us.us.1, %forinc138.us.us
  %s.3.us.us.1 = phi i32 [ %248, %bounds.ok152.us.us.1 ], [ %s.3.us.us, %forinc138.us.us ] ; [#uses = 3, type = i32]
  %249 = add nuw i64 %__key114.0465.us.us, 2      ; [#uses = 2]
  %niter.nsub.1 = add i64 %niter, -2              ; [#uses = 2]
  %niter.ncmp.1 = icmp eq i64 %niter.nsub.1, 0    ; [#uses = 1]
  br i1 %niter.ncmp.1, label %endfor139.loopexit.unr-lcssa, label %forbody137.us.us
}

; [#uses = 3]
; Function Attrs: nofree nounwind
declare i32 @scanf(i8* nocapture readonly, ...) local_unnamed_addr #6

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

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

; [#uses = 1]
; Function Attrs: nofree nounwind
declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr #6

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

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

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

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

; [#uses = 2]
; Function Attrs: nounwind readnone willreturn
declare i32 @llvm.experimental.vector.reduce.mul.v4i32(<4 x i32>) #8

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

!llvm.ldc.typeinfo._D11TypeInfo_Ai6__initZ = !{!0}
!llvm.ldc.typeinfo._D12TypeInfo_AAi6__initZ = !{!1}
!llvm.ldc.typeinfo._D11TypeInfo_Ab6__initZ = !{!2}
!llvm.ident = !{!3}

!0 = !{{ i64, i32* } undef}
!1 = !{{ i64, { i64, i32* }* } undef}
!2 = !{{ i64, i8* } undef}
!3 = !{!"ldc version 1.28.0"}
!4 = distinct !{!4, !5}
!5 = !{!"llvm.loop.isvectorized", i32 1}
!6 = distinct !{!6, !7}
!7 = !{!"llvm.loop.unroll.disable"}
!8 = distinct !{!8, !9, !5}
!9 = !{!"llvm.loop.unroll.runtime.disable"}
!10 = !{i8 0, i8 2}
!11 = distinct !{!11, !5}
!12 = distinct !{!12, !7}
!13 = distinct !{!13, !9, !5}
