program example
	implicit none
    
    integer N,A(3,3),i,j,k,count
    integer,allocatable :: b(:)
    
    do i=1,3
    	read(*,*) A(i,1:3)
    end do
    
    read(*,*) N
    
    allocate (b(N))
    
    do i=1,N
    	read(*,*) b(i)
    end do
    
    do i=1,3
    	count=0
    	do j=1,3
        	do k=1,N
            	if(A(i,j)==b(k)) then
                	count=count+1
                end if
            end do
        end do
        if (count==3) then
        	write(*,*) "Yes"
         	goto 1
    	end if       
    end do

    do i=1,3
    	count=0
    	do j=1,3
        	do k=1,N
            	if(A(j,i)==b(k)) then
                	count=count+1
                end if
            end do
        end do
        if (count==3) then
        	write(*,*) "Yes"
         	goto 1
    	end if       
    end do
    
    count=0
    
    do i=1,3
    	do j=1,N
    		if(A(i,i)==b(j)) then
            	count=count+1
            end if
        end do
    end do
    
    if (count==3) then
    	write(*,*) "Yes"
        goto 1
    end if
    
    count=0
    
    do i=1,N
    	if(A(1,3)==b(i)) then
        	count=count+1
        end if

    	if(A(2,2)==b(i)) then
        	count=count+1
        end if

    	if(A(3,1)==b(i)) then
        	count=count+1
        end if
    end do
    
    if (count==3) then
    	write(*,*) "Yes"
        goto 1
    end if
    
    write(*,*) "No"
    
    
1 end program example
; ModuleID = 'FIRModule'
source_filename = "FIRModule"
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"

@_QFEa = internal global [3 x [3 x i32]] undef
@_QFEb.0 = internal unnamed_addr global ptr null
@_QQcl.8be76318bc2fce4006217a94205be1be = linkonce constant [73 x i8] c"/home/ubuntu/Downloads/TheStack_IR/Collated/Fortran/Source_2273/source.f\00"
@_QQcl.596573 = linkonce constant [3 x i8] c"Yes"
@_QQcl.4E6F = linkonce constant [2 x i8] c"No"
@_QQEnvironmentDefaults = local_unnamed_addr constant ptr null

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #0

define void @_QQmain() local_unnamed_addr {
  %1 = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, align 8
  %2 = alloca i32, align 4
  %.fca.1.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 1
  %.fca.2.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 2
  %.fca.3.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 3
  %.fca.4.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 4
  %.fca.5.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 5
  %.fca.6.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 6
  %.fca.7.0.0.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 0
  %.fca.7.0.1.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 1
  %.fca.7.0.2.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 2
  %3 = tail call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 8)
  store ptr @_QFEa, ptr %1, align 8, !tbaa !3
  store i64 4, ptr %.fca.1.gep, align 8, !tbaa !3
  store i32 20180515, ptr %.fca.2.gep, align 8, !tbaa !3
  store i8 1, ptr %.fca.3.gep, align 4, !tbaa !3
  store i8 9, ptr %.fca.4.gep, align 1, !tbaa !3
  store i8 0, ptr %.fca.5.gep, align 2, !tbaa !3
  store i8 0, ptr %.fca.6.gep, align 1, !tbaa !3
  store i64 1, ptr %.fca.7.0.0.gep, align 8, !tbaa !3
  store i64 3, ptr %.fca.7.0.1.gep, align 8, !tbaa !3
  store i64 12, ptr %.fca.7.0.2.gep, align 8, !tbaa !3
  %4 = call i1 @_FortranAioInputDescriptor(ptr %3, ptr nonnull %1)
  %5 = call i32 @_FortranAioEndIoStatement(ptr %3)
  %6 = call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 8)
  store ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 1), ptr %1, align 8, !tbaa !3
  store i64 4, ptr %.fca.1.gep, align 8, !tbaa !3
  store i32 20180515, ptr %.fca.2.gep, align 8, !tbaa !3
  store i8 1, ptr %.fca.3.gep, align 4, !tbaa !3
  store i8 9, ptr %.fca.4.gep, align 1, !tbaa !3
  store i8 0, ptr %.fca.5.gep, align 2, !tbaa !3
  store i8 0, ptr %.fca.6.gep, align 1, !tbaa !3
  store i64 1, ptr %.fca.7.0.0.gep, align 8, !tbaa !3
  store i64 3, ptr %.fca.7.0.1.gep, align 8, !tbaa !3
  store i64 12, ptr %.fca.7.0.2.gep, align 8, !tbaa !3
  %7 = call i1 @_FortranAioInputDescriptor(ptr %6, ptr nonnull %1)
  %8 = call i32 @_FortranAioEndIoStatement(ptr %6)
  %9 = call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 8)
  store ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 2), ptr %1, align 8, !tbaa !3
  store i64 4, ptr %.fca.1.gep, align 8, !tbaa !3
  store i32 20180515, ptr %.fca.2.gep, align 8, !tbaa !3
  store i8 1, ptr %.fca.3.gep, align 4, !tbaa !3
  store i8 9, ptr %.fca.4.gep, align 1, !tbaa !3
  store i8 0, ptr %.fca.5.gep, align 2, !tbaa !3
  store i8 0, ptr %.fca.6.gep, align 1, !tbaa !3
  store i64 1, ptr %.fca.7.0.0.gep, align 8, !tbaa !3
  store i64 3, ptr %.fca.7.0.1.gep, align 8, !tbaa !3
  store i64 12, ptr %.fca.7.0.2.gep, align 8, !tbaa !3
  %10 = call i1 @_FortranAioInputDescriptor(ptr %9, ptr nonnull %1)
  %11 = call i32 @_FortranAioEndIoStatement(ptr %9)
  %12 = call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 11)
  %13 = call i1 @_FortranAioInputInteger(ptr %12, ptr nonnull %2, i32 4)
  %14 = call i32 @_FortranAioEndIoStatement(ptr %12)
  %15 = load i32, ptr %2, align 4, !tbaa !7
  %16 = call i32 @llvm.smax.i32(i32 %15, i32 0)
  %17 = zext i32 %16 to i64
  %18 = shl nuw nsw i64 %17, 2
  %19 = call ptr @malloc(i64 %18)
  store ptr %19, ptr @_QFEb.0, align 8, !tbaa !3
  %20 = sext i32 %15 to i64
  %21 = icmp sgt i32 %15, 0
  br i1 %21, label %.lr.ph, label %._crit_edge.thread

.preheader306:                                    ; preds = %.lr.ph
  %.pre = load i32, ptr %2, align 4, !tbaa !7
  %.unpack276.pre = load ptr, ptr @_QFEb.0, align 8
  %.pre399 = sext i32 %.pre to i64
  %22 = icmp sgt i32 %.pre, 0
  br i1 %22, label %.preheader305.us.preheader, label %._crit_edge.thread

.preheader305.us.preheader:                       ; preds = %.preheader306
  %23 = load i32, ptr @_QFEa, align 16, !tbaa !7
  %min.iters.check = icmp ult i32 %.pre, 8
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.preheader305.us.preheader
  %n.vec = and i64 %.pre399, -8
  %ind.end = or i64 %n.vec, 1
  %broadcast.splatinsert = insertelement <4 x i32> poison, i32 %23, i64 0
  %broadcast.splat = shufflevector <4 x i32> %broadcast.splatinsert, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert444 = insertelement <4 x i32> poison, i32 %23, i64 0
  %broadcast.splat445 = shufflevector <4 x i32> %broadcast.splatinsert444, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.phi = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ %30, %vector.body ]
  %vec.phi442 = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ %31, %vector.body ]
  %24 = getelementptr i32, ptr %.unpack276.pre, i64 %index
  %wide.load = load <4 x i32>, ptr %24, align 4, !tbaa !7
  %25 = getelementptr i32, ptr %24, i64 4
  %wide.load443 = load <4 x i32>, ptr %25, align 4, !tbaa !7
  %26 = icmp eq <4 x i32> %broadcast.splat, %wide.load
  %27 = icmp eq <4 x i32> %broadcast.splat445, %wide.load443
  %28 = zext <4 x i1> %26 to <4 x i32>
  %29 = zext <4 x i1> %27 to <4 x i32>
  %30 = add <4 x i32> %vec.phi, %28
  %31 = add <4 x i32> %vec.phi442, %29
  %index.next = add nuw i64 %index, 8
  %32 = icmp eq i64 %index.next, %n.vec
  br i1 %32, label %middle.block, label %vector.body, !llvm.loop !9

middle.block:                                     ; preds = %vector.body
  %bin.rdx = add <4 x i32> %31, %30
  %33 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx)
  %cmp.n = icmp eq i64 %n.vec, %.pre399
  br i1 %cmp.n, label %._crit_edge.us.us, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %.preheader305.us.preheader, %middle.block
  %indvars.iv339.ph = phi i64 [ 1, %.preheader305.us.preheader ], [ %ind.end, %middle.block ]
  %.1196307.us.us.ph = phi i32 [ 0, %.preheader305.us.preheader ], [ %33, %middle.block ]
  br label %scalar.ph

.preheader305.us.1:                               ; preds = %._crit_edge.us.us.2
  %34 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 1), align 4, !tbaa !7
  %min.iters.check494 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check494, label %scalar.ph493.preheader, label %vector.ph495

vector.ph495:                                     ; preds = %.preheader305.us.1
  %n.vec497 = and i64 %.pre399, -8
  %ind.end498 = or i64 %n.vec497, 1
  %broadcast.splatinsert508 = insertelement <4 x i32> poison, i32 %34, i64 0
  %broadcast.splat509 = shufflevector <4 x i32> %broadcast.splatinsert508, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert510 = insertelement <4 x i32> poison, i32 %34, i64 0
  %broadcast.splat511 = shufflevector <4 x i32> %broadcast.splatinsert510, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body501

vector.body501:                                   ; preds = %vector.body501, %vector.ph495
  %index502 = phi i64 [ 0, %vector.ph495 ], [ %index.next512, %vector.body501 ]
  %vec.phi503 = phi <4 x i32> [ zeroinitializer, %vector.ph495 ], [ %41, %vector.body501 ]
  %vec.phi504 = phi <4 x i32> [ zeroinitializer, %vector.ph495 ], [ %42, %vector.body501 ]
  %35 = getelementptr i32, ptr %.unpack276.pre, i64 %index502
  %wide.load506 = load <4 x i32>, ptr %35, align 4, !tbaa !7
  %36 = getelementptr i32, ptr %35, i64 4
  %wide.load507 = load <4 x i32>, ptr %36, align 4, !tbaa !7
  %37 = icmp eq <4 x i32> %broadcast.splat509, %wide.load506
  %38 = icmp eq <4 x i32> %broadcast.splat511, %wide.load507
  %39 = zext <4 x i1> %37 to <4 x i32>
  %40 = zext <4 x i1> %38 to <4 x i32>
  %41 = add <4 x i32> %vec.phi503, %39
  %42 = add <4 x i32> %vec.phi504, %40
  %index.next512 = add nuw i64 %index502, 8
  %43 = icmp eq i64 %index.next512, %n.vec497
  br i1 %43, label %middle.block492, label %vector.body501, !llvm.loop !12

middle.block492:                                  ; preds = %vector.body501
  %bin.rdx513 = add <4 x i32> %42, %41
  %44 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx513)
  %cmp.n500 = icmp eq i64 %n.vec497, %.pre399
  br i1 %cmp.n500, label %._crit_edge.us.us.1354, label %scalar.ph493.preheader

scalar.ph493.preheader:                           ; preds = %.preheader305.us.1, %middle.block492
  %indvars.iv339.1348.ph = phi i64 [ 1, %.preheader305.us.1 ], [ %ind.end498, %middle.block492 ]
  %.1196307.us.us.1349.ph = phi i32 [ 0, %.preheader305.us.1 ], [ %44, %middle.block492 ]
  br label %scalar.ph493

scalar.ph493:                                     ; preds = %scalar.ph493.preheader, %scalar.ph493
  %indvars.iv339.1348 = phi i64 [ %indvars.iv.next340.1351, %scalar.ph493 ], [ %indvars.iv339.1348.ph, %scalar.ph493.preheader ]
  %.1196307.us.us.1349 = phi i32 [ %spec.select.us.us.1350, %scalar.ph493 ], [ %.1196307.us.us.1349.ph, %scalar.ph493.preheader ]
  %45 = add i64 %indvars.iv339.1348, -1
  %46 = getelementptr i32, ptr %.unpack276.pre, i64 %45
  %47 = load i32, ptr %46, align 4, !tbaa !7
  %48 = icmp eq i32 %34, %47
  %49 = zext i1 %48 to i32
  %spec.select.us.us.1350 = add i32 %.1196307.us.us.1349, %49
  %indvars.iv.next340.1351 = add nuw nsw i64 %indvars.iv339.1348, 1
  %exitcond342.1352.not = icmp eq i64 %indvars.iv339.1348, %.pre399
  br i1 %exitcond342.1352.not, label %._crit_edge.us.us.1354, label %scalar.ph493, !llvm.loop !13

._crit_edge.us.us.1354:                           ; preds = %scalar.ph493, %middle.block492
  %spec.select.us.us.1350.lcssa = phi i32 [ %44, %middle.block492 ], [ %spec.select.us.us.1350, %scalar.ph493 ]
  %50 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 1), align 16, !tbaa !7
  %min.iters.check517 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check517, label %scalar.ph516.preheader, label %vector.ph518

vector.ph518:                                     ; preds = %._crit_edge.us.us.1354
  %n.vec520 = and i64 %.pre399, -8
  %ind.end521 = or i64 %n.vec520, 1
  %51 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.1350.lcssa, i64 0
  %broadcast.splatinsert531 = insertelement <4 x i32> poison, i32 %50, i64 0
  %broadcast.splat532 = shufflevector <4 x i32> %broadcast.splatinsert531, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert533 = insertelement <4 x i32> poison, i32 %50, i64 0
  %broadcast.splat534 = shufflevector <4 x i32> %broadcast.splatinsert533, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body524

vector.body524:                                   ; preds = %vector.body524, %vector.ph518
  %index525 = phi i64 [ 0, %vector.ph518 ], [ %index.next535, %vector.body524 ]
  %vec.phi526 = phi <4 x i32> [ %51, %vector.ph518 ], [ %58, %vector.body524 ]
  %vec.phi527 = phi <4 x i32> [ zeroinitializer, %vector.ph518 ], [ %59, %vector.body524 ]
  %52 = getelementptr i32, ptr %.unpack276.pre, i64 %index525
  %wide.load529 = load <4 x i32>, ptr %52, align 4, !tbaa !7
  %53 = getelementptr i32, ptr %52, i64 4
  %wide.load530 = load <4 x i32>, ptr %53, align 4, !tbaa !7
  %54 = icmp eq <4 x i32> %broadcast.splat532, %wide.load529
  %55 = icmp eq <4 x i32> %broadcast.splat534, %wide.load530
  %56 = zext <4 x i1> %54 to <4 x i32>
  %57 = zext <4 x i1> %55 to <4 x i32>
  %58 = add <4 x i32> %vec.phi526, %56
  %59 = add <4 x i32> %vec.phi527, %57
  %index.next535 = add nuw i64 %index525, 8
  %60 = icmp eq i64 %index.next535, %n.vec520
  br i1 %60, label %middle.block515, label %vector.body524, !llvm.loop !14

middle.block515:                                  ; preds = %vector.body524
  %bin.rdx536 = add <4 x i32> %59, %58
  %61 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx536)
  %cmp.n523 = icmp eq i64 %n.vec520, %.pre399
  br i1 %cmp.n523, label %._crit_edge.us.us.1.1, label %scalar.ph516.preheader

scalar.ph516.preheader:                           ; preds = %._crit_edge.us.us.1354, %middle.block515
  %indvars.iv339.1.1.ph = phi i64 [ 1, %._crit_edge.us.us.1354 ], [ %ind.end521, %middle.block515 ]
  %.1196307.us.us.1.1.ph = phi i32 [ %spec.select.us.us.1350.lcssa, %._crit_edge.us.us.1354 ], [ %61, %middle.block515 ]
  br label %scalar.ph516

scalar.ph516:                                     ; preds = %scalar.ph516.preheader, %scalar.ph516
  %indvars.iv339.1.1 = phi i64 [ %indvars.iv.next340.1.1, %scalar.ph516 ], [ %indvars.iv339.1.1.ph, %scalar.ph516.preheader ]
  %.1196307.us.us.1.1 = phi i32 [ %spec.select.us.us.1.1, %scalar.ph516 ], [ %.1196307.us.us.1.1.ph, %scalar.ph516.preheader ]
  %62 = add i64 %indvars.iv339.1.1, -1
  %63 = getelementptr i32, ptr %.unpack276.pre, i64 %62
  %64 = load i32, ptr %63, align 4, !tbaa !7
  %65 = icmp eq i32 %50, %64
  %66 = zext i1 %65 to i32
  %spec.select.us.us.1.1 = add i32 %.1196307.us.us.1.1, %66
  %indvars.iv.next340.1.1 = add nuw nsw i64 %indvars.iv339.1.1, 1
  %exitcond342.1.1.not = icmp eq i64 %indvars.iv339.1.1, %.pre399
  br i1 %exitcond342.1.1.not, label %._crit_edge.us.us.1.1, label %scalar.ph516, !llvm.loop !15

._crit_edge.us.us.1.1:                            ; preds = %scalar.ph516, %middle.block515
  %spec.select.us.us.1.1.lcssa = phi i32 [ %61, %middle.block515 ], [ %spec.select.us.us.1.1, %scalar.ph516 ]
  %67 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 1), align 4, !tbaa !7
  %min.iters.check540 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check540, label %scalar.ph539.preheader, label %vector.ph541

vector.ph541:                                     ; preds = %._crit_edge.us.us.1.1
  %n.vec543 = and i64 %.pre399, -8
  %ind.end544 = or i64 %n.vec543, 1
  %68 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.1.1.lcssa, i64 0
  %broadcast.splatinsert554 = insertelement <4 x i32> poison, i32 %67, i64 0
  %broadcast.splat555 = shufflevector <4 x i32> %broadcast.splatinsert554, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert556 = insertelement <4 x i32> poison, i32 %67, i64 0
  %broadcast.splat557 = shufflevector <4 x i32> %broadcast.splatinsert556, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body547

vector.body547:                                   ; preds = %vector.body547, %vector.ph541
  %index548 = phi i64 [ 0, %vector.ph541 ], [ %index.next558, %vector.body547 ]
  %vec.phi549 = phi <4 x i32> [ %68, %vector.ph541 ], [ %75, %vector.body547 ]
  %vec.phi550 = phi <4 x i32> [ zeroinitializer, %vector.ph541 ], [ %76, %vector.body547 ]
  %69 = getelementptr i32, ptr %.unpack276.pre, i64 %index548
  %wide.load552 = load <4 x i32>, ptr %69, align 4, !tbaa !7
  %70 = getelementptr i32, ptr %69, i64 4
  %wide.load553 = load <4 x i32>, ptr %70, align 4, !tbaa !7
  %71 = icmp eq <4 x i32> %broadcast.splat555, %wide.load552
  %72 = icmp eq <4 x i32> %broadcast.splat557, %wide.load553
  %73 = zext <4 x i1> %71 to <4 x i32>
  %74 = zext <4 x i1> %72 to <4 x i32>
  %75 = add <4 x i32> %vec.phi549, %73
  %76 = add <4 x i32> %vec.phi550, %74
  %index.next558 = add nuw i64 %index548, 8
  %77 = icmp eq i64 %index.next558, %n.vec543
  br i1 %77, label %middle.block538, label %vector.body547, !llvm.loop !16

middle.block538:                                  ; preds = %vector.body547
  %bin.rdx559 = add <4 x i32> %76, %75
  %78 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx559)
  %cmp.n546 = icmp eq i64 %n.vec543, %.pre399
  br i1 %cmp.n546, label %._crit_edge.us.us.2.1, label %scalar.ph539.preheader

scalar.ph539.preheader:                           ; preds = %._crit_edge.us.us.1.1, %middle.block538
  %indvars.iv339.2.1.ph = phi i64 [ 1, %._crit_edge.us.us.1.1 ], [ %ind.end544, %middle.block538 ]
  %.1196307.us.us.2.1.ph = phi i32 [ %spec.select.us.us.1.1.lcssa, %._crit_edge.us.us.1.1 ], [ %78, %middle.block538 ]
  br label %scalar.ph539

scalar.ph539:                                     ; preds = %scalar.ph539.preheader, %scalar.ph539
  %indvars.iv339.2.1 = phi i64 [ %indvars.iv.next340.2.1, %scalar.ph539 ], [ %indvars.iv339.2.1.ph, %scalar.ph539.preheader ]
  %.1196307.us.us.2.1 = phi i32 [ %spec.select.us.us.2.1, %scalar.ph539 ], [ %.1196307.us.us.2.1.ph, %scalar.ph539.preheader ]
  %79 = add i64 %indvars.iv339.2.1, -1
  %80 = getelementptr i32, ptr %.unpack276.pre, i64 %79
  %81 = load i32, ptr %80, align 4, !tbaa !7
  %82 = icmp eq i32 %67, %81
  %83 = zext i1 %82 to i32
  %spec.select.us.us.2.1 = add i32 %.1196307.us.us.2.1, %83
  %indvars.iv.next340.2.1 = add nuw nsw i64 %indvars.iv339.2.1, 1
  %exitcond342.2.1.not = icmp eq i64 %indvars.iv339.2.1, %.pre399
  br i1 %exitcond342.2.1.not, label %._crit_edge.us.us.2.1, label %scalar.ph539, !llvm.loop !17

._crit_edge.us.us.2.1:                            ; preds = %scalar.ph539, %middle.block538
  %spec.select.us.us.2.1.lcssa = phi i32 [ %78, %middle.block538 ], [ %spec.select.us.us.2.1, %scalar.ph539 ]
  %84 = icmp eq i32 %spec.select.us.us.2.1.lcssa, 3
  br i1 %84, label %.split313.us, label %.preheader305.us.2

.preheader305.us.2:                               ; preds = %._crit_edge.us.us.2.1
  %85 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 2), align 8, !tbaa !7
  %min.iters.check563 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check563, label %scalar.ph562.preheader, label %vector.ph564

vector.ph564:                                     ; preds = %.preheader305.us.2
  %n.vec566 = and i64 %.pre399, -8
  %ind.end567 = or i64 %n.vec566, 1
  %broadcast.splatinsert577 = insertelement <4 x i32> poison, i32 %85, i64 0
  %broadcast.splat578 = shufflevector <4 x i32> %broadcast.splatinsert577, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert579 = insertelement <4 x i32> poison, i32 %85, i64 0
  %broadcast.splat580 = shufflevector <4 x i32> %broadcast.splatinsert579, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body570

vector.body570:                                   ; preds = %vector.body570, %vector.ph564
  %index571 = phi i64 [ 0, %vector.ph564 ], [ %index.next581, %vector.body570 ]
  %vec.phi572 = phi <4 x i32> [ zeroinitializer, %vector.ph564 ], [ %92, %vector.body570 ]
  %vec.phi573 = phi <4 x i32> [ zeroinitializer, %vector.ph564 ], [ %93, %vector.body570 ]
  %86 = getelementptr i32, ptr %.unpack276.pre, i64 %index571
  %wide.load575 = load <4 x i32>, ptr %86, align 4, !tbaa !7
  %87 = getelementptr i32, ptr %86, i64 4
  %wide.load576 = load <4 x i32>, ptr %87, align 4, !tbaa !7
  %88 = icmp eq <4 x i32> %broadcast.splat578, %wide.load575
  %89 = icmp eq <4 x i32> %broadcast.splat580, %wide.load576
  %90 = zext <4 x i1> %88 to <4 x i32>
  %91 = zext <4 x i1> %89 to <4 x i32>
  %92 = add <4 x i32> %vec.phi572, %90
  %93 = add <4 x i32> %vec.phi573, %91
  %index.next581 = add nuw i64 %index571, 8
  %94 = icmp eq i64 %index.next581, %n.vec566
  br i1 %94, label %middle.block561, label %vector.body570, !llvm.loop !18

middle.block561:                                  ; preds = %vector.body570
  %bin.rdx582 = add <4 x i32> %93, %92
  %95 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx582)
  %cmp.n569 = icmp eq i64 %n.vec566, %.pre399
  br i1 %cmp.n569, label %._crit_edge.us.us.2361, label %scalar.ph562.preheader

scalar.ph562.preheader:                           ; preds = %.preheader305.us.2, %middle.block561
  %indvars.iv339.2355.ph = phi i64 [ 1, %.preheader305.us.2 ], [ %ind.end567, %middle.block561 ]
  %.1196307.us.us.2356.ph = phi i32 [ 0, %.preheader305.us.2 ], [ %95, %middle.block561 ]
  br label %scalar.ph562

scalar.ph562:                                     ; preds = %scalar.ph562.preheader, %scalar.ph562
  %indvars.iv339.2355 = phi i64 [ %indvars.iv.next340.2358, %scalar.ph562 ], [ %indvars.iv339.2355.ph, %scalar.ph562.preheader ]
  %.1196307.us.us.2356 = phi i32 [ %spec.select.us.us.2357, %scalar.ph562 ], [ %.1196307.us.us.2356.ph, %scalar.ph562.preheader ]
  %96 = add i64 %indvars.iv339.2355, -1
  %97 = getelementptr i32, ptr %.unpack276.pre, i64 %96
  %98 = load i32, ptr %97, align 4, !tbaa !7
  %99 = icmp eq i32 %85, %98
  %100 = zext i1 %99 to i32
  %spec.select.us.us.2357 = add i32 %.1196307.us.us.2356, %100
  %indvars.iv.next340.2358 = add nuw nsw i64 %indvars.iv339.2355, 1
  %exitcond342.2359.not = icmp eq i64 %indvars.iv339.2355, %.pre399
  br i1 %exitcond342.2359.not, label %._crit_edge.us.us.2361, label %scalar.ph562, !llvm.loop !19

._crit_edge.us.us.2361:                           ; preds = %scalar.ph562, %middle.block561
  %spec.select.us.us.2357.lcssa = phi i32 [ %95, %middle.block561 ], [ %spec.select.us.us.2357, %scalar.ph562 ]
  %101 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 2), align 4, !tbaa !7
  %min.iters.check586 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check586, label %scalar.ph585.preheader, label %vector.ph587

vector.ph587:                                     ; preds = %._crit_edge.us.us.2361
  %n.vec589 = and i64 %.pre399, -8
  %ind.end590 = or i64 %n.vec589, 1
  %102 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.2357.lcssa, i64 0
  %broadcast.splatinsert600 = insertelement <4 x i32> poison, i32 %101, i64 0
  %broadcast.splat601 = shufflevector <4 x i32> %broadcast.splatinsert600, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert602 = insertelement <4 x i32> poison, i32 %101, i64 0
  %broadcast.splat603 = shufflevector <4 x i32> %broadcast.splatinsert602, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body593

vector.body593:                                   ; preds = %vector.body593, %vector.ph587
  %index594 = phi i64 [ 0, %vector.ph587 ], [ %index.next604, %vector.body593 ]
  %vec.phi595 = phi <4 x i32> [ %102, %vector.ph587 ], [ %109, %vector.body593 ]
  %vec.phi596 = phi <4 x i32> [ zeroinitializer, %vector.ph587 ], [ %110, %vector.body593 ]
  %103 = getelementptr i32, ptr %.unpack276.pre, i64 %index594
  %wide.load598 = load <4 x i32>, ptr %103, align 4, !tbaa !7
  %104 = getelementptr i32, ptr %103, i64 4
  %wide.load599 = load <4 x i32>, ptr %104, align 4, !tbaa !7
  %105 = icmp eq <4 x i32> %broadcast.splat601, %wide.load598
  %106 = icmp eq <4 x i32> %broadcast.splat603, %wide.load599
  %107 = zext <4 x i1> %105 to <4 x i32>
  %108 = zext <4 x i1> %106 to <4 x i32>
  %109 = add <4 x i32> %vec.phi595, %107
  %110 = add <4 x i32> %vec.phi596, %108
  %index.next604 = add nuw i64 %index594, 8
  %111 = icmp eq i64 %index.next604, %n.vec589
  br i1 %111, label %middle.block584, label %vector.body593, !llvm.loop !20

middle.block584:                                  ; preds = %vector.body593
  %bin.rdx605 = add <4 x i32> %110, %109
  %112 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx605)
  %cmp.n592 = icmp eq i64 %n.vec589, %.pre399
  br i1 %cmp.n592, label %._crit_edge.us.us.1.2, label %scalar.ph585.preheader

scalar.ph585.preheader:                           ; preds = %._crit_edge.us.us.2361, %middle.block584
  %indvars.iv339.1.2.ph = phi i64 [ 1, %._crit_edge.us.us.2361 ], [ %ind.end590, %middle.block584 ]
  %.1196307.us.us.1.2.ph = phi i32 [ %spec.select.us.us.2357.lcssa, %._crit_edge.us.us.2361 ], [ %112, %middle.block584 ]
  br label %scalar.ph585

scalar.ph585:                                     ; preds = %scalar.ph585.preheader, %scalar.ph585
  %indvars.iv339.1.2 = phi i64 [ %indvars.iv.next340.1.2, %scalar.ph585 ], [ %indvars.iv339.1.2.ph, %scalar.ph585.preheader ]
  %.1196307.us.us.1.2 = phi i32 [ %spec.select.us.us.1.2, %scalar.ph585 ], [ %.1196307.us.us.1.2.ph, %scalar.ph585.preheader ]
  %113 = add i64 %indvars.iv339.1.2, -1
  %114 = getelementptr i32, ptr %.unpack276.pre, i64 %113
  %115 = load i32, ptr %114, align 4, !tbaa !7
  %116 = icmp eq i32 %101, %115
  %117 = zext i1 %116 to i32
  %spec.select.us.us.1.2 = add i32 %.1196307.us.us.1.2, %117
  %indvars.iv.next340.1.2 = add nuw nsw i64 %indvars.iv339.1.2, 1
  %exitcond342.1.2.not = icmp eq i64 %indvars.iv339.1.2, %.pre399
  br i1 %exitcond342.1.2.not, label %._crit_edge.us.us.1.2, label %scalar.ph585, !llvm.loop !21

._crit_edge.us.us.1.2:                            ; preds = %scalar.ph585, %middle.block584
  %spec.select.us.us.1.2.lcssa = phi i32 [ %112, %middle.block584 ], [ %spec.select.us.us.1.2, %scalar.ph585 ]
  %118 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 2), align 16, !tbaa !7
  %min.iters.check609 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check609, label %scalar.ph608.preheader, label %vector.ph610

vector.ph610:                                     ; preds = %._crit_edge.us.us.1.2
  %n.vec612 = and i64 %.pre399, -8
  %ind.end613 = or i64 %n.vec612, 1
  %119 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.1.2.lcssa, i64 0
  %broadcast.splatinsert623 = insertelement <4 x i32> poison, i32 %118, i64 0
  %broadcast.splat624 = shufflevector <4 x i32> %broadcast.splatinsert623, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert625 = insertelement <4 x i32> poison, i32 %118, i64 0
  %broadcast.splat626 = shufflevector <4 x i32> %broadcast.splatinsert625, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body616

vector.body616:                                   ; preds = %vector.body616, %vector.ph610
  %index617 = phi i64 [ 0, %vector.ph610 ], [ %index.next627, %vector.body616 ]
  %vec.phi618 = phi <4 x i32> [ %119, %vector.ph610 ], [ %126, %vector.body616 ]
  %vec.phi619 = phi <4 x i32> [ zeroinitializer, %vector.ph610 ], [ %127, %vector.body616 ]
  %120 = getelementptr i32, ptr %.unpack276.pre, i64 %index617
  %wide.load621 = load <4 x i32>, ptr %120, align 4, !tbaa !7
  %121 = getelementptr i32, ptr %120, i64 4
  %wide.load622 = load <4 x i32>, ptr %121, align 4, !tbaa !7
  %122 = icmp eq <4 x i32> %broadcast.splat624, %wide.load621
  %123 = icmp eq <4 x i32> %broadcast.splat626, %wide.load622
  %124 = zext <4 x i1> %122 to <4 x i32>
  %125 = zext <4 x i1> %123 to <4 x i32>
  %126 = add <4 x i32> %vec.phi618, %124
  %127 = add <4 x i32> %vec.phi619, %125
  %index.next627 = add nuw i64 %index617, 8
  %128 = icmp eq i64 %index.next627, %n.vec612
  br i1 %128, label %middle.block607, label %vector.body616, !llvm.loop !22

middle.block607:                                  ; preds = %vector.body616
  %bin.rdx628 = add <4 x i32> %127, %126
  %129 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx628)
  %cmp.n615 = icmp eq i64 %n.vec612, %.pre399
  br i1 %cmp.n615, label %._crit_edge.us.us.2.2, label %scalar.ph608.preheader

scalar.ph608.preheader:                           ; preds = %._crit_edge.us.us.1.2, %middle.block607
  %indvars.iv339.2.2.ph = phi i64 [ 1, %._crit_edge.us.us.1.2 ], [ %ind.end613, %middle.block607 ]
  %.1196307.us.us.2.2.ph = phi i32 [ %spec.select.us.us.1.2.lcssa, %._crit_edge.us.us.1.2 ], [ %129, %middle.block607 ]
  br label %scalar.ph608

scalar.ph608:                                     ; preds = %scalar.ph608.preheader, %scalar.ph608
  %indvars.iv339.2.2 = phi i64 [ %indvars.iv.next340.2.2, %scalar.ph608 ], [ %indvars.iv339.2.2.ph, %scalar.ph608.preheader ]
  %.1196307.us.us.2.2 = phi i32 [ %spec.select.us.us.2.2, %scalar.ph608 ], [ %.1196307.us.us.2.2.ph, %scalar.ph608.preheader ]
  %130 = add i64 %indvars.iv339.2.2, -1
  %131 = getelementptr i32, ptr %.unpack276.pre, i64 %130
  %132 = load i32, ptr %131, align 4, !tbaa !7
  %133 = icmp eq i32 %118, %132
  %134 = zext i1 %133 to i32
  %spec.select.us.us.2.2 = add i32 %.1196307.us.us.2.2, %134
  %indvars.iv.next340.2.2 = add nuw nsw i64 %indvars.iv339.2.2, 1
  %exitcond342.2.2.not = icmp eq i64 %indvars.iv339.2.2, %.pre399
  br i1 %exitcond342.2.2.not, label %._crit_edge.us.us.2.2, label %scalar.ph608, !llvm.loop !23

._crit_edge.us.us.2.2:                            ; preds = %scalar.ph608, %middle.block607
  %spec.select.us.us.2.2.lcssa = phi i32 [ %129, %middle.block607 ], [ %spec.select.us.us.2.2, %scalar.ph608 ]
  %135 = icmp eq i32 %spec.select.us.us.2.2.lcssa, 3
  br i1 %135, label %.split313.us, label %.preheader304

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv339 = phi i64 [ %indvars.iv.next340, %scalar.ph ], [ %indvars.iv339.ph, %scalar.ph.preheader ]
  %.1196307.us.us = phi i32 [ %spec.select.us.us, %scalar.ph ], [ %.1196307.us.us.ph, %scalar.ph.preheader ]
  %136 = add i64 %indvars.iv339, -1
  %137 = getelementptr i32, ptr %.unpack276.pre, i64 %136
  %138 = load i32, ptr %137, align 4, !tbaa !7
  %139 = icmp eq i32 %23, %138
  %140 = zext i1 %139 to i32
  %spec.select.us.us = add i32 %.1196307.us.us, %140
  %indvars.iv.next340 = add nuw nsw i64 %indvars.iv339, 1
  %exitcond342.not = icmp eq i64 %indvars.iv339, %.pre399
  br i1 %exitcond342.not, label %._crit_edge.us.us, label %scalar.ph, !llvm.loop !24

._crit_edge.us.us:                                ; preds = %scalar.ph, %middle.block
  %spec.select.us.us.lcssa = phi i32 [ %33, %middle.block ], [ %spec.select.us.us, %scalar.ph ]
  %141 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 0), align 4, !tbaa !7
  %min.iters.check448 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check448, label %scalar.ph447.preheader, label %vector.ph449

vector.ph449:                                     ; preds = %._crit_edge.us.us
  %n.vec451 = and i64 %.pre399, -8
  %ind.end452 = or i64 %n.vec451, 1
  %142 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.lcssa, i64 0
  %broadcast.splatinsert462 = insertelement <4 x i32> poison, i32 %141, i64 0
  %broadcast.splat463 = shufflevector <4 x i32> %broadcast.splatinsert462, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert464 = insertelement <4 x i32> poison, i32 %141, i64 0
  %broadcast.splat465 = shufflevector <4 x i32> %broadcast.splatinsert464, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body455

vector.body455:                                   ; preds = %vector.body455, %vector.ph449
  %index456 = phi i64 [ 0, %vector.ph449 ], [ %index.next466, %vector.body455 ]
  %vec.phi457 = phi <4 x i32> [ %142, %vector.ph449 ], [ %149, %vector.body455 ]
  %vec.phi458 = phi <4 x i32> [ zeroinitializer, %vector.ph449 ], [ %150, %vector.body455 ]
  %143 = getelementptr i32, ptr %.unpack276.pre, i64 %index456
  %wide.load460 = load <4 x i32>, ptr %143, align 4, !tbaa !7
  %144 = getelementptr i32, ptr %143, i64 4
  %wide.load461 = load <4 x i32>, ptr %144, align 4, !tbaa !7
  %145 = icmp eq <4 x i32> %broadcast.splat463, %wide.load460
  %146 = icmp eq <4 x i32> %broadcast.splat465, %wide.load461
  %147 = zext <4 x i1> %145 to <4 x i32>
  %148 = zext <4 x i1> %146 to <4 x i32>
  %149 = add <4 x i32> %vec.phi457, %147
  %150 = add <4 x i32> %vec.phi458, %148
  %index.next466 = add nuw i64 %index456, 8
  %151 = icmp eq i64 %index.next466, %n.vec451
  br i1 %151, label %middle.block446, label %vector.body455, !llvm.loop !25

middle.block446:                                  ; preds = %vector.body455
  %bin.rdx467 = add <4 x i32> %150, %149
  %152 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx467)
  %cmp.n454 = icmp eq i64 %n.vec451, %.pre399
  br i1 %cmp.n454, label %._crit_edge.us.us.1, label %scalar.ph447.preheader

scalar.ph447.preheader:                           ; preds = %._crit_edge.us.us, %middle.block446
  %indvars.iv339.1.ph = phi i64 [ 1, %._crit_edge.us.us ], [ %ind.end452, %middle.block446 ]
  %.1196307.us.us.1.ph = phi i32 [ %spec.select.us.us.lcssa, %._crit_edge.us.us ], [ %152, %middle.block446 ]
  br label %scalar.ph447

scalar.ph447:                                     ; preds = %scalar.ph447.preheader, %scalar.ph447
  %indvars.iv339.1 = phi i64 [ %indvars.iv.next340.1, %scalar.ph447 ], [ %indvars.iv339.1.ph, %scalar.ph447.preheader ]
  %.1196307.us.us.1 = phi i32 [ %spec.select.us.us.1, %scalar.ph447 ], [ %.1196307.us.us.1.ph, %scalar.ph447.preheader ]
  %153 = add i64 %indvars.iv339.1, -1
  %154 = getelementptr i32, ptr %.unpack276.pre, i64 %153
  %155 = load i32, ptr %154, align 4, !tbaa !7
  %156 = icmp eq i32 %141, %155
  %157 = zext i1 %156 to i32
  %spec.select.us.us.1 = add i32 %.1196307.us.us.1, %157
  %indvars.iv.next340.1 = add nuw nsw i64 %indvars.iv339.1, 1
  %exitcond342.1.not = icmp eq i64 %indvars.iv339.1, %.pre399
  br i1 %exitcond342.1.not, label %._crit_edge.us.us.1, label %scalar.ph447, !llvm.loop !26

._crit_edge.us.us.1:                              ; preds = %scalar.ph447, %middle.block446
  %spec.select.us.us.1.lcssa = phi i32 [ %152, %middle.block446 ], [ %spec.select.us.us.1, %scalar.ph447 ]
  %158 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 0), align 8, !tbaa !7
  %min.iters.check471 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check471, label %scalar.ph470.preheader, label %vector.ph472

vector.ph472:                                     ; preds = %._crit_edge.us.us.1
  %n.vec474 = and i64 %.pre399, -8
  %ind.end475 = or i64 %n.vec474, 1
  %159 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select.us.us.1.lcssa, i64 0
  %broadcast.splatinsert485 = insertelement <4 x i32> poison, i32 %158, i64 0
  %broadcast.splat486 = shufflevector <4 x i32> %broadcast.splatinsert485, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert487 = insertelement <4 x i32> poison, i32 %158, i64 0
  %broadcast.splat488 = shufflevector <4 x i32> %broadcast.splatinsert487, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body478

vector.body478:                                   ; preds = %vector.body478, %vector.ph472
  %index479 = phi i64 [ 0, %vector.ph472 ], [ %index.next489, %vector.body478 ]
  %vec.phi480 = phi <4 x i32> [ %159, %vector.ph472 ], [ %166, %vector.body478 ]
  %vec.phi481 = phi <4 x i32> [ zeroinitializer, %vector.ph472 ], [ %167, %vector.body478 ]
  %160 = getelementptr i32, ptr %.unpack276.pre, i64 %index479
  %wide.load483 = load <4 x i32>, ptr %160, align 4, !tbaa !7
  %161 = getelementptr i32, ptr %160, i64 4
  %wide.load484 = load <4 x i32>, ptr %161, align 4, !tbaa !7
  %162 = icmp eq <4 x i32> %broadcast.splat486, %wide.load483
  %163 = icmp eq <4 x i32> %broadcast.splat488, %wide.load484
  %164 = zext <4 x i1> %162 to <4 x i32>
  %165 = zext <4 x i1> %163 to <4 x i32>
  %166 = add <4 x i32> %vec.phi480, %164
  %167 = add <4 x i32> %vec.phi481, %165
  %index.next489 = add nuw i64 %index479, 8
  %168 = icmp eq i64 %index.next489, %n.vec474
  br i1 %168, label %middle.block469, label %vector.body478, !llvm.loop !27

middle.block469:                                  ; preds = %vector.body478
  %bin.rdx490 = add <4 x i32> %167, %166
  %169 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx490)
  %cmp.n477 = icmp eq i64 %n.vec474, %.pre399
  br i1 %cmp.n477, label %._crit_edge.us.us.2, label %scalar.ph470.preheader

scalar.ph470.preheader:                           ; preds = %._crit_edge.us.us.1, %middle.block469
  %indvars.iv339.2.ph = phi i64 [ 1, %._crit_edge.us.us.1 ], [ %ind.end475, %middle.block469 ]
  %.1196307.us.us.2.ph = phi i32 [ %spec.select.us.us.1.lcssa, %._crit_edge.us.us.1 ], [ %169, %middle.block469 ]
  br label %scalar.ph470

scalar.ph470:                                     ; preds = %scalar.ph470.preheader, %scalar.ph470
  %indvars.iv339.2 = phi i64 [ %indvars.iv.next340.2, %scalar.ph470 ], [ %indvars.iv339.2.ph, %scalar.ph470.preheader ]
  %.1196307.us.us.2 = phi i32 [ %spec.select.us.us.2, %scalar.ph470 ], [ %.1196307.us.us.2.ph, %scalar.ph470.preheader ]
  %170 = add i64 %indvars.iv339.2, -1
  %171 = getelementptr i32, ptr %.unpack276.pre, i64 %170
  %172 = load i32, ptr %171, align 4, !tbaa !7
  %173 = icmp eq i32 %158, %172
  %174 = zext i1 %173 to i32
  %spec.select.us.us.2 = add i32 %.1196307.us.us.2, %174
  %indvars.iv.next340.2 = add nuw nsw i64 %indvars.iv339.2, 1
  %exitcond342.2.not = icmp eq i64 %indvars.iv339.2, %.pre399
  br i1 %exitcond342.2.not, label %._crit_edge.us.us.2, label %scalar.ph470, !llvm.loop !28

._crit_edge.us.us.2:                              ; preds = %scalar.ph470, %middle.block469
  %spec.select.us.us.2.lcssa = phi i32 [ %169, %middle.block469 ], [ %spec.select.us.us.2, %scalar.ph470 ]
  %175 = icmp eq i32 %spec.select.us.us.2.lcssa, 3
  br i1 %175, label %.split313.us, label %.preheader305.us.1

.lr.ph:                                           ; preds = %0, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ 1, %0 ]
  %176 = call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 16)
  %.unpack288 = load ptr, ptr @_QFEb.0, align 8, !tbaa !3
  %177 = add nsw i64 %indvars.iv, -1
  %178 = getelementptr i32, ptr %.unpack288, i64 %177
  %179 = call i1 @_FortranAioInputInteger(ptr %176, ptr %178, i32 4)
  %180 = call i32 @_FortranAioEndIoStatement(ptr %176)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv, %20
  br i1 %exitcond.not, label %.preheader306, label %.lr.ph

.preheader304:                                    ; preds = %._crit_edge.us.us.2.2
  br i1 %22, label %.preheader303.us.preheader, label %._crit_edge.thread

.preheader303.us.preheader:                       ; preds = %.preheader304
  %181 = load i32, ptr @_QFEa, align 16, !tbaa !7
  %min.iters.check632 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check632, label %scalar.ph631.preheader, label %vector.ph633

vector.ph633:                                     ; preds = %.preheader303.us.preheader
  %n.vec635 = and i64 %.pre399, -8
  %ind.end636 = or i64 %n.vec635, 1
  %broadcast.splatinsert646 = insertelement <4 x i32> poison, i32 %181, i64 0
  %broadcast.splat647 = shufflevector <4 x i32> %broadcast.splatinsert646, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert648 = insertelement <4 x i32> poison, i32 %181, i64 0
  %broadcast.splat649 = shufflevector <4 x i32> %broadcast.splatinsert648, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body639

vector.body639:                                   ; preds = %vector.body639, %vector.ph633
  %index640 = phi i64 [ 0, %vector.ph633 ], [ %index.next650, %vector.body639 ]
  %vec.phi641 = phi <4 x i32> [ zeroinitializer, %vector.ph633 ], [ %188, %vector.body639 ]
  %vec.phi642 = phi <4 x i32> [ zeroinitializer, %vector.ph633 ], [ %189, %vector.body639 ]
  %182 = getelementptr i32, ptr %.unpack276.pre, i64 %index640
  %wide.load644 = load <4 x i32>, ptr %182, align 4, !tbaa !7
  %183 = getelementptr i32, ptr %182, i64 4
  %wide.load645 = load <4 x i32>, ptr %183, align 4, !tbaa !7
  %184 = icmp eq <4 x i32> %broadcast.splat647, %wide.load644
  %185 = icmp eq <4 x i32> %broadcast.splat649, %wide.load645
  %186 = zext <4 x i1> %184 to <4 x i32>
  %187 = zext <4 x i1> %185 to <4 x i32>
  %188 = add <4 x i32> %vec.phi641, %186
  %189 = add <4 x i32> %vec.phi642, %187
  %index.next650 = add nuw i64 %index640, 8
  %190 = icmp eq i64 %index.next650, %n.vec635
  br i1 %190, label %middle.block630, label %vector.body639, !llvm.loop !29

middle.block630:                                  ; preds = %vector.body639
  %bin.rdx651 = add <4 x i32> %189, %188
  %191 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx651)
  %cmp.n638 = icmp eq i64 %n.vec635, %.pre399
  br i1 %cmp.n638, label %._crit_edge.us.us322, label %scalar.ph631.preheader

scalar.ph631.preheader:                           ; preds = %.preheader303.us.preheader, %middle.block630
  %indvars.iv362.ph = phi i64 [ 1, %.preheader303.us.preheader ], [ %ind.end636, %middle.block630 ]
  %.4314.us.us.ph = phi i32 [ 0, %.preheader303.us.preheader ], [ %191, %middle.block630 ]
  br label %scalar.ph631

.preheader303.us.1:                               ; preds = %._crit_edge.us.us322.2
  %192 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 0), align 4, !tbaa !7
  %min.iters.check701 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check701, label %scalar.ph700.preheader, label %vector.ph702

vector.ph702:                                     ; preds = %.preheader303.us.1
  %n.vec704 = and i64 %.pre399, -8
  %ind.end705 = or i64 %n.vec704, 1
  %broadcast.splatinsert715 = insertelement <4 x i32> poison, i32 %192, i64 0
  %broadcast.splat716 = shufflevector <4 x i32> %broadcast.splatinsert715, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert717 = insertelement <4 x i32> poison, i32 %192, i64 0
  %broadcast.splat718 = shufflevector <4 x i32> %broadcast.splatinsert717, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body708

vector.body708:                                   ; preds = %vector.body708, %vector.ph702
  %index709 = phi i64 [ 0, %vector.ph702 ], [ %index.next719, %vector.body708 ]
  %vec.phi710 = phi <4 x i32> [ zeroinitializer, %vector.ph702 ], [ %199, %vector.body708 ]
  %vec.phi711 = phi <4 x i32> [ zeroinitializer, %vector.ph702 ], [ %200, %vector.body708 ]
  %193 = getelementptr i32, ptr %.unpack276.pre, i64 %index709
  %wide.load713 = load <4 x i32>, ptr %193, align 4, !tbaa !7
  %194 = getelementptr i32, ptr %193, i64 4
  %wide.load714 = load <4 x i32>, ptr %194, align 4, !tbaa !7
  %195 = icmp eq <4 x i32> %broadcast.splat716, %wide.load713
  %196 = icmp eq <4 x i32> %broadcast.splat718, %wide.load714
  %197 = zext <4 x i1> %195 to <4 x i32>
  %198 = zext <4 x i1> %196 to <4 x i32>
  %199 = add <4 x i32> %vec.phi710, %197
  %200 = add <4 x i32> %vec.phi711, %198
  %index.next719 = add nuw i64 %index709, 8
  %201 = icmp eq i64 %index.next719, %n.vec704
  br i1 %201, label %middle.block699, label %vector.body708, !llvm.loop !30

middle.block699:                                  ; preds = %vector.body708
  %bin.rdx720 = add <4 x i32> %200, %199
  %202 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx720)
  %cmp.n707 = icmp eq i64 %n.vec704, %.pre399
  br i1 %cmp.n707, label %._crit_edge.us.us322.1377, label %scalar.ph700.preheader

scalar.ph700.preheader:                           ; preds = %.preheader303.us.1, %middle.block699
  %indvars.iv362.1371.ph = phi i64 [ 1, %.preheader303.us.1 ], [ %ind.end705, %middle.block699 ]
  %.4314.us.us.1372.ph = phi i32 [ 0, %.preheader303.us.1 ], [ %202, %middle.block699 ]
  br label %scalar.ph700

scalar.ph700:                                     ; preds = %scalar.ph700.preheader, %scalar.ph700
  %indvars.iv362.1371 = phi i64 [ %indvars.iv.next363.1374, %scalar.ph700 ], [ %indvars.iv362.1371.ph, %scalar.ph700.preheader ]
  %.4314.us.us.1372 = phi i32 [ %spec.select300.us.us.1373, %scalar.ph700 ], [ %.4314.us.us.1372.ph, %scalar.ph700.preheader ]
  %203 = add i64 %indvars.iv362.1371, -1
  %204 = getelementptr i32, ptr %.unpack276.pre, i64 %203
  %205 = load i32, ptr %204, align 4, !tbaa !7
  %206 = icmp eq i32 %192, %205
  %207 = zext i1 %206 to i32
  %spec.select300.us.us.1373 = add i32 %.4314.us.us.1372, %207
  %indvars.iv.next363.1374 = add nuw nsw i64 %indvars.iv362.1371, 1
  %exitcond365.1375.not = icmp eq i64 %indvars.iv362.1371, %.pre399
  br i1 %exitcond365.1375.not, label %._crit_edge.us.us322.1377, label %scalar.ph700, !llvm.loop !31

._crit_edge.us.us322.1377:                        ; preds = %scalar.ph700, %middle.block699
  %spec.select300.us.us.1373.lcssa = phi i32 [ %202, %middle.block699 ], [ %spec.select300.us.us.1373, %scalar.ph700 ]
  %208 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 1), align 16, !tbaa !7
  %min.iters.check724 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check724, label %scalar.ph723.preheader, label %vector.ph725

vector.ph725:                                     ; preds = %._crit_edge.us.us322.1377
  %n.vec727 = and i64 %.pre399, -8
  %ind.end728 = or i64 %n.vec727, 1
  %209 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.1373.lcssa, i64 0
  %broadcast.splatinsert738 = insertelement <4 x i32> poison, i32 %208, i64 0
  %broadcast.splat739 = shufflevector <4 x i32> %broadcast.splatinsert738, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert740 = insertelement <4 x i32> poison, i32 %208, i64 0
  %broadcast.splat741 = shufflevector <4 x i32> %broadcast.splatinsert740, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body731

vector.body731:                                   ; preds = %vector.body731, %vector.ph725
  %index732 = phi i64 [ 0, %vector.ph725 ], [ %index.next742, %vector.body731 ]
  %vec.phi733 = phi <4 x i32> [ %209, %vector.ph725 ], [ %216, %vector.body731 ]
  %vec.phi734 = phi <4 x i32> [ zeroinitializer, %vector.ph725 ], [ %217, %vector.body731 ]
  %210 = getelementptr i32, ptr %.unpack276.pre, i64 %index732
  %wide.load736 = load <4 x i32>, ptr %210, align 4, !tbaa !7
  %211 = getelementptr i32, ptr %210, i64 4
  %wide.load737 = load <4 x i32>, ptr %211, align 4, !tbaa !7
  %212 = icmp eq <4 x i32> %broadcast.splat739, %wide.load736
  %213 = icmp eq <4 x i32> %broadcast.splat741, %wide.load737
  %214 = zext <4 x i1> %212 to <4 x i32>
  %215 = zext <4 x i1> %213 to <4 x i32>
  %216 = add <4 x i32> %vec.phi733, %214
  %217 = add <4 x i32> %vec.phi734, %215
  %index.next742 = add nuw i64 %index732, 8
  %218 = icmp eq i64 %index.next742, %n.vec727
  br i1 %218, label %middle.block722, label %vector.body731, !llvm.loop !32

middle.block722:                                  ; preds = %vector.body731
  %bin.rdx743 = add <4 x i32> %217, %216
  %219 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx743)
  %cmp.n730 = icmp eq i64 %n.vec727, %.pre399
  br i1 %cmp.n730, label %._crit_edge.us.us322.1.1, label %scalar.ph723.preheader

scalar.ph723.preheader:                           ; preds = %._crit_edge.us.us322.1377, %middle.block722
  %indvars.iv362.1.1.ph = phi i64 [ 1, %._crit_edge.us.us322.1377 ], [ %ind.end728, %middle.block722 ]
  %.4314.us.us.1.1.ph = phi i32 [ %spec.select300.us.us.1373.lcssa, %._crit_edge.us.us322.1377 ], [ %219, %middle.block722 ]
  br label %scalar.ph723

scalar.ph723:                                     ; preds = %scalar.ph723.preheader, %scalar.ph723
  %indvars.iv362.1.1 = phi i64 [ %indvars.iv.next363.1.1, %scalar.ph723 ], [ %indvars.iv362.1.1.ph, %scalar.ph723.preheader ]
  %.4314.us.us.1.1 = phi i32 [ %spec.select300.us.us.1.1, %scalar.ph723 ], [ %.4314.us.us.1.1.ph, %scalar.ph723.preheader ]
  %220 = add i64 %indvars.iv362.1.1, -1
  %221 = getelementptr i32, ptr %.unpack276.pre, i64 %220
  %222 = load i32, ptr %221, align 4, !tbaa !7
  %223 = icmp eq i32 %208, %222
  %224 = zext i1 %223 to i32
  %spec.select300.us.us.1.1 = add i32 %.4314.us.us.1.1, %224
  %indvars.iv.next363.1.1 = add nuw nsw i64 %indvars.iv362.1.1, 1
  %exitcond365.1.1.not = icmp eq i64 %indvars.iv362.1.1, %.pre399
  br i1 %exitcond365.1.1.not, label %._crit_edge.us.us322.1.1, label %scalar.ph723, !llvm.loop !33

._crit_edge.us.us322.1.1:                         ; preds = %scalar.ph723, %middle.block722
  %spec.select300.us.us.1.1.lcssa = phi i32 [ %219, %middle.block722 ], [ %spec.select300.us.us.1.1, %scalar.ph723 ]
  %225 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 2), align 4, !tbaa !7
  %min.iters.check747 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check747, label %scalar.ph746.preheader, label %vector.ph748

vector.ph748:                                     ; preds = %._crit_edge.us.us322.1.1
  %n.vec750 = and i64 %.pre399, -8
  %ind.end751 = or i64 %n.vec750, 1
  %226 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.1.1.lcssa, i64 0
  %broadcast.splatinsert761 = insertelement <4 x i32> poison, i32 %225, i64 0
  %broadcast.splat762 = shufflevector <4 x i32> %broadcast.splatinsert761, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert763 = insertelement <4 x i32> poison, i32 %225, i64 0
  %broadcast.splat764 = shufflevector <4 x i32> %broadcast.splatinsert763, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body754

vector.body754:                                   ; preds = %vector.body754, %vector.ph748
  %index755 = phi i64 [ 0, %vector.ph748 ], [ %index.next765, %vector.body754 ]
  %vec.phi756 = phi <4 x i32> [ %226, %vector.ph748 ], [ %233, %vector.body754 ]
  %vec.phi757 = phi <4 x i32> [ zeroinitializer, %vector.ph748 ], [ %234, %vector.body754 ]
  %227 = getelementptr i32, ptr %.unpack276.pre, i64 %index755
  %wide.load759 = load <4 x i32>, ptr %227, align 4, !tbaa !7
  %228 = getelementptr i32, ptr %227, i64 4
  %wide.load760 = load <4 x i32>, ptr %228, align 4, !tbaa !7
  %229 = icmp eq <4 x i32> %broadcast.splat762, %wide.load759
  %230 = icmp eq <4 x i32> %broadcast.splat764, %wide.load760
  %231 = zext <4 x i1> %229 to <4 x i32>
  %232 = zext <4 x i1> %230 to <4 x i32>
  %233 = add <4 x i32> %vec.phi756, %231
  %234 = add <4 x i32> %vec.phi757, %232
  %index.next765 = add nuw i64 %index755, 8
  %235 = icmp eq i64 %index.next765, %n.vec750
  br i1 %235, label %middle.block745, label %vector.body754, !llvm.loop !34

middle.block745:                                  ; preds = %vector.body754
  %bin.rdx766 = add <4 x i32> %234, %233
  %236 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx766)
  %cmp.n753 = icmp eq i64 %n.vec750, %.pre399
  br i1 %cmp.n753, label %._crit_edge.us.us322.2.1, label %scalar.ph746.preheader

scalar.ph746.preheader:                           ; preds = %._crit_edge.us.us322.1.1, %middle.block745
  %indvars.iv362.2.1.ph = phi i64 [ 1, %._crit_edge.us.us322.1.1 ], [ %ind.end751, %middle.block745 ]
  %.4314.us.us.2.1.ph = phi i32 [ %spec.select300.us.us.1.1.lcssa, %._crit_edge.us.us322.1.1 ], [ %236, %middle.block745 ]
  br label %scalar.ph746

scalar.ph746:                                     ; preds = %scalar.ph746.preheader, %scalar.ph746
  %indvars.iv362.2.1 = phi i64 [ %indvars.iv.next363.2.1, %scalar.ph746 ], [ %indvars.iv362.2.1.ph, %scalar.ph746.preheader ]
  %.4314.us.us.2.1 = phi i32 [ %spec.select300.us.us.2.1, %scalar.ph746 ], [ %.4314.us.us.2.1.ph, %scalar.ph746.preheader ]
  %237 = add i64 %indvars.iv362.2.1, -1
  %238 = getelementptr i32, ptr %.unpack276.pre, i64 %237
  %239 = load i32, ptr %238, align 4, !tbaa !7
  %240 = icmp eq i32 %225, %239
  %241 = zext i1 %240 to i32
  %spec.select300.us.us.2.1 = add i32 %.4314.us.us.2.1, %241
  %indvars.iv.next363.2.1 = add nuw nsw i64 %indvars.iv362.2.1, 1
  %exitcond365.2.1.not = icmp eq i64 %indvars.iv362.2.1, %.pre399
  br i1 %exitcond365.2.1.not, label %._crit_edge.us.us322.2.1, label %scalar.ph746, !llvm.loop !35

._crit_edge.us.us322.2.1:                         ; preds = %scalar.ph746, %middle.block745
  %spec.select300.us.us.2.1.lcssa = phi i32 [ %236, %middle.block745 ], [ %spec.select300.us.us.2.1, %scalar.ph746 ]
  %242 = icmp eq i32 %spec.select300.us.us.2.1.lcssa, 3
  br i1 %242, label %.split325.us, label %.preheader303.us.2

.preheader303.us.2:                               ; preds = %._crit_edge.us.us322.2.1
  %243 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 0), align 8, !tbaa !7
  %min.iters.check770 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check770, label %scalar.ph769.preheader, label %vector.ph771

vector.ph771:                                     ; preds = %.preheader303.us.2
  %n.vec773 = and i64 %.pre399, -8
  %ind.end774 = or i64 %n.vec773, 1
  %broadcast.splatinsert784 = insertelement <4 x i32> poison, i32 %243, i64 0
  %broadcast.splat785 = shufflevector <4 x i32> %broadcast.splatinsert784, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert786 = insertelement <4 x i32> poison, i32 %243, i64 0
  %broadcast.splat787 = shufflevector <4 x i32> %broadcast.splatinsert786, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body777

vector.body777:                                   ; preds = %vector.body777, %vector.ph771
  %index778 = phi i64 [ 0, %vector.ph771 ], [ %index.next788, %vector.body777 ]
  %vec.phi779 = phi <4 x i32> [ zeroinitializer, %vector.ph771 ], [ %250, %vector.body777 ]
  %vec.phi780 = phi <4 x i32> [ zeroinitializer, %vector.ph771 ], [ %251, %vector.body777 ]
  %244 = getelementptr i32, ptr %.unpack276.pre, i64 %index778
  %wide.load782 = load <4 x i32>, ptr %244, align 4, !tbaa !7
  %245 = getelementptr i32, ptr %244, i64 4
  %wide.load783 = load <4 x i32>, ptr %245, align 4, !tbaa !7
  %246 = icmp eq <4 x i32> %broadcast.splat785, %wide.load782
  %247 = icmp eq <4 x i32> %broadcast.splat787, %wide.load783
  %248 = zext <4 x i1> %246 to <4 x i32>
  %249 = zext <4 x i1> %247 to <4 x i32>
  %250 = add <4 x i32> %vec.phi779, %248
  %251 = add <4 x i32> %vec.phi780, %249
  %index.next788 = add nuw i64 %index778, 8
  %252 = icmp eq i64 %index.next788, %n.vec773
  br i1 %252, label %middle.block768, label %vector.body777, !llvm.loop !36

middle.block768:                                  ; preds = %vector.body777
  %bin.rdx789 = add <4 x i32> %251, %250
  %253 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx789)
  %cmp.n776 = icmp eq i64 %n.vec773, %.pre399
  br i1 %cmp.n776, label %._crit_edge.us.us322.2384, label %scalar.ph769.preheader

scalar.ph769.preheader:                           ; preds = %.preheader303.us.2, %middle.block768
  %indvars.iv362.2378.ph = phi i64 [ 1, %.preheader303.us.2 ], [ %ind.end774, %middle.block768 ]
  %.4314.us.us.2379.ph = phi i32 [ 0, %.preheader303.us.2 ], [ %253, %middle.block768 ]
  br label %scalar.ph769

scalar.ph769:                                     ; preds = %scalar.ph769.preheader, %scalar.ph769
  %indvars.iv362.2378 = phi i64 [ %indvars.iv.next363.2381, %scalar.ph769 ], [ %indvars.iv362.2378.ph, %scalar.ph769.preheader ]
  %.4314.us.us.2379 = phi i32 [ %spec.select300.us.us.2380, %scalar.ph769 ], [ %.4314.us.us.2379.ph, %scalar.ph769.preheader ]
  %254 = add i64 %indvars.iv362.2378, -1
  %255 = getelementptr i32, ptr %.unpack276.pre, i64 %254
  %256 = load i32, ptr %255, align 4, !tbaa !7
  %257 = icmp eq i32 %243, %256
  %258 = zext i1 %257 to i32
  %spec.select300.us.us.2380 = add i32 %.4314.us.us.2379, %258
  %indvars.iv.next363.2381 = add nuw nsw i64 %indvars.iv362.2378, 1
  %exitcond365.2382.not = icmp eq i64 %indvars.iv362.2378, %.pre399
  br i1 %exitcond365.2382.not, label %._crit_edge.us.us322.2384, label %scalar.ph769, !llvm.loop !37

._crit_edge.us.us322.2384:                        ; preds = %scalar.ph769, %middle.block768
  %spec.select300.us.us.2380.lcssa = phi i32 [ %253, %middle.block768 ], [ %spec.select300.us.us.2380, %scalar.ph769 ]
  %259 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 1), align 4, !tbaa !7
  %min.iters.check793 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check793, label %scalar.ph792.preheader, label %vector.ph794

vector.ph794:                                     ; preds = %._crit_edge.us.us322.2384
  %n.vec796 = and i64 %.pre399, -8
  %ind.end797 = or i64 %n.vec796, 1
  %260 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.2380.lcssa, i64 0
  %broadcast.splatinsert807 = insertelement <4 x i32> poison, i32 %259, i64 0
  %broadcast.splat808 = shufflevector <4 x i32> %broadcast.splatinsert807, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert809 = insertelement <4 x i32> poison, i32 %259, i64 0
  %broadcast.splat810 = shufflevector <4 x i32> %broadcast.splatinsert809, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body800

vector.body800:                                   ; preds = %vector.body800, %vector.ph794
  %index801 = phi i64 [ 0, %vector.ph794 ], [ %index.next811, %vector.body800 ]
  %vec.phi802 = phi <4 x i32> [ %260, %vector.ph794 ], [ %267, %vector.body800 ]
  %vec.phi803 = phi <4 x i32> [ zeroinitializer, %vector.ph794 ], [ %268, %vector.body800 ]
  %261 = getelementptr i32, ptr %.unpack276.pre, i64 %index801
  %wide.load805 = load <4 x i32>, ptr %261, align 4, !tbaa !7
  %262 = getelementptr i32, ptr %261, i64 4
  %wide.load806 = load <4 x i32>, ptr %262, align 4, !tbaa !7
  %263 = icmp eq <4 x i32> %broadcast.splat808, %wide.load805
  %264 = icmp eq <4 x i32> %broadcast.splat810, %wide.load806
  %265 = zext <4 x i1> %263 to <4 x i32>
  %266 = zext <4 x i1> %264 to <4 x i32>
  %267 = add <4 x i32> %vec.phi802, %265
  %268 = add <4 x i32> %vec.phi803, %266
  %index.next811 = add nuw i64 %index801, 8
  %269 = icmp eq i64 %index.next811, %n.vec796
  br i1 %269, label %middle.block791, label %vector.body800, !llvm.loop !38

middle.block791:                                  ; preds = %vector.body800
  %bin.rdx812 = add <4 x i32> %268, %267
  %270 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx812)
  %cmp.n799 = icmp eq i64 %n.vec796, %.pre399
  br i1 %cmp.n799, label %._crit_edge.us.us322.1.2, label %scalar.ph792.preheader

scalar.ph792.preheader:                           ; preds = %._crit_edge.us.us322.2384, %middle.block791
  %indvars.iv362.1.2.ph = phi i64 [ 1, %._crit_edge.us.us322.2384 ], [ %ind.end797, %middle.block791 ]
  %.4314.us.us.1.2.ph = phi i32 [ %spec.select300.us.us.2380.lcssa, %._crit_edge.us.us322.2384 ], [ %270, %middle.block791 ]
  br label %scalar.ph792

scalar.ph792:                                     ; preds = %scalar.ph792.preheader, %scalar.ph792
  %indvars.iv362.1.2 = phi i64 [ %indvars.iv.next363.1.2, %scalar.ph792 ], [ %indvars.iv362.1.2.ph, %scalar.ph792.preheader ]
  %.4314.us.us.1.2 = phi i32 [ %spec.select300.us.us.1.2, %scalar.ph792 ], [ %.4314.us.us.1.2.ph, %scalar.ph792.preheader ]
  %271 = add i64 %indvars.iv362.1.2, -1
  %272 = getelementptr i32, ptr %.unpack276.pre, i64 %271
  %273 = load i32, ptr %272, align 4, !tbaa !7
  %274 = icmp eq i32 %259, %273
  %275 = zext i1 %274 to i32
  %spec.select300.us.us.1.2 = add i32 %.4314.us.us.1.2, %275
  %indvars.iv.next363.1.2 = add nuw nsw i64 %indvars.iv362.1.2, 1
  %exitcond365.1.2.not = icmp eq i64 %indvars.iv362.1.2, %.pre399
  br i1 %exitcond365.1.2.not, label %._crit_edge.us.us322.1.2, label %scalar.ph792, !llvm.loop !39

._crit_edge.us.us322.1.2:                         ; preds = %scalar.ph792, %middle.block791
  %spec.select300.us.us.1.2.lcssa = phi i32 [ %270, %middle.block791 ], [ %spec.select300.us.us.1.2, %scalar.ph792 ]
  %276 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 2), align 16, !tbaa !7
  %min.iters.check816 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check816, label %scalar.ph815.preheader, label %vector.ph817

vector.ph817:                                     ; preds = %._crit_edge.us.us322.1.2
  %n.vec819 = and i64 %.pre399, -8
  %ind.end820 = or i64 %n.vec819, 1
  %277 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.1.2.lcssa, i64 0
  %broadcast.splatinsert830 = insertelement <4 x i32> poison, i32 %276, i64 0
  %broadcast.splat831 = shufflevector <4 x i32> %broadcast.splatinsert830, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert832 = insertelement <4 x i32> poison, i32 %276, i64 0
  %broadcast.splat833 = shufflevector <4 x i32> %broadcast.splatinsert832, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body823

vector.body823:                                   ; preds = %vector.body823, %vector.ph817
  %index824 = phi i64 [ 0, %vector.ph817 ], [ %index.next834, %vector.body823 ]
  %vec.phi825 = phi <4 x i32> [ %277, %vector.ph817 ], [ %284, %vector.body823 ]
  %vec.phi826 = phi <4 x i32> [ zeroinitializer, %vector.ph817 ], [ %285, %vector.body823 ]
  %278 = getelementptr i32, ptr %.unpack276.pre, i64 %index824
  %wide.load828 = load <4 x i32>, ptr %278, align 4, !tbaa !7
  %279 = getelementptr i32, ptr %278, i64 4
  %wide.load829 = load <4 x i32>, ptr %279, align 4, !tbaa !7
  %280 = icmp eq <4 x i32> %broadcast.splat831, %wide.load828
  %281 = icmp eq <4 x i32> %broadcast.splat833, %wide.load829
  %282 = zext <4 x i1> %280 to <4 x i32>
  %283 = zext <4 x i1> %281 to <4 x i32>
  %284 = add <4 x i32> %vec.phi825, %282
  %285 = add <4 x i32> %vec.phi826, %283
  %index.next834 = add nuw i64 %index824, 8
  %286 = icmp eq i64 %index.next834, %n.vec819
  br i1 %286, label %middle.block814, label %vector.body823, !llvm.loop !40

middle.block814:                                  ; preds = %vector.body823
  %bin.rdx835 = add <4 x i32> %285, %284
  %287 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx835)
  %cmp.n822 = icmp eq i64 %n.vec819, %.pre399
  br i1 %cmp.n822, label %._crit_edge.us.us322.2.2, label %scalar.ph815.preheader

scalar.ph815.preheader:                           ; preds = %._crit_edge.us.us322.1.2, %middle.block814
  %indvars.iv362.2.2.ph = phi i64 [ 1, %._crit_edge.us.us322.1.2 ], [ %ind.end820, %middle.block814 ]
  %.4314.us.us.2.2.ph = phi i32 [ %spec.select300.us.us.1.2.lcssa, %._crit_edge.us.us322.1.2 ], [ %287, %middle.block814 ]
  br label %scalar.ph815

scalar.ph815:                                     ; preds = %scalar.ph815.preheader, %scalar.ph815
  %indvars.iv362.2.2 = phi i64 [ %indvars.iv.next363.2.2, %scalar.ph815 ], [ %indvars.iv362.2.2.ph, %scalar.ph815.preheader ]
  %.4314.us.us.2.2 = phi i32 [ %spec.select300.us.us.2.2, %scalar.ph815 ], [ %.4314.us.us.2.2.ph, %scalar.ph815.preheader ]
  %288 = add i64 %indvars.iv362.2.2, -1
  %289 = getelementptr i32, ptr %.unpack276.pre, i64 %288
  %290 = load i32, ptr %289, align 4, !tbaa !7
  %291 = icmp eq i32 %276, %290
  %292 = zext i1 %291 to i32
  %spec.select300.us.us.2.2 = add i32 %.4314.us.us.2.2, %292
  %indvars.iv.next363.2.2 = add nuw nsw i64 %indvars.iv362.2.2, 1
  %exitcond365.2.2.not = icmp eq i64 %indvars.iv362.2.2, %.pre399
  br i1 %exitcond365.2.2.not, label %._crit_edge.us.us322.2.2, label %scalar.ph815, !llvm.loop !41

._crit_edge.us.us322.2.2:                         ; preds = %scalar.ph815, %middle.block814
  %spec.select300.us.us.2.2.lcssa = phi i32 [ %287, %middle.block814 ], [ %spec.select300.us.us.2.2, %scalar.ph815 ]
  %293 = icmp eq i32 %spec.select300.us.us.2.2.lcssa, 3
  br i1 %293, label %.split325.us, label %.preheader

scalar.ph631:                                     ; preds = %scalar.ph631.preheader, %scalar.ph631
  %indvars.iv362 = phi i64 [ %indvars.iv.next363, %scalar.ph631 ], [ %indvars.iv362.ph, %scalar.ph631.preheader ]
  %.4314.us.us = phi i32 [ %spec.select300.us.us, %scalar.ph631 ], [ %.4314.us.us.ph, %scalar.ph631.preheader ]
  %294 = add i64 %indvars.iv362, -1
  %295 = getelementptr i32, ptr %.unpack276.pre, i64 %294
  %296 = load i32, ptr %295, align 4, !tbaa !7
  %297 = icmp eq i32 %181, %296
  %298 = zext i1 %297 to i32
  %spec.select300.us.us = add i32 %.4314.us.us, %298
  %indvars.iv.next363 = add nuw nsw i64 %indvars.iv362, 1
  %exitcond365.not = icmp eq i64 %indvars.iv362, %.pre399
  br i1 %exitcond365.not, label %._crit_edge.us.us322, label %scalar.ph631, !llvm.loop !42

._crit_edge.us.us322:                             ; preds = %scalar.ph631, %middle.block630
  %spec.select300.us.us.lcssa = phi i32 [ %191, %middle.block630 ], [ %spec.select300.us.us, %scalar.ph631 ]
  %299 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 1), align 4, !tbaa !7
  %min.iters.check655 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check655, label %scalar.ph654.preheader, label %vector.ph656

vector.ph656:                                     ; preds = %._crit_edge.us.us322
  %n.vec658 = and i64 %.pre399, -8
  %ind.end659 = or i64 %n.vec658, 1
  %300 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.lcssa, i64 0
  %broadcast.splatinsert669 = insertelement <4 x i32> poison, i32 %299, i64 0
  %broadcast.splat670 = shufflevector <4 x i32> %broadcast.splatinsert669, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert671 = insertelement <4 x i32> poison, i32 %299, i64 0
  %broadcast.splat672 = shufflevector <4 x i32> %broadcast.splatinsert671, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body662

vector.body662:                                   ; preds = %vector.body662, %vector.ph656
  %index663 = phi i64 [ 0, %vector.ph656 ], [ %index.next673, %vector.body662 ]
  %vec.phi664 = phi <4 x i32> [ %300, %vector.ph656 ], [ %307, %vector.body662 ]
  %vec.phi665 = phi <4 x i32> [ zeroinitializer, %vector.ph656 ], [ %308, %vector.body662 ]
  %301 = getelementptr i32, ptr %.unpack276.pre, i64 %index663
  %wide.load667 = load <4 x i32>, ptr %301, align 4, !tbaa !7
  %302 = getelementptr i32, ptr %301, i64 4
  %wide.load668 = load <4 x i32>, ptr %302, align 4, !tbaa !7
  %303 = icmp eq <4 x i32> %broadcast.splat670, %wide.load667
  %304 = icmp eq <4 x i32> %broadcast.splat672, %wide.load668
  %305 = zext <4 x i1> %303 to <4 x i32>
  %306 = zext <4 x i1> %304 to <4 x i32>
  %307 = add <4 x i32> %vec.phi664, %305
  %308 = add <4 x i32> %vec.phi665, %306
  %index.next673 = add nuw i64 %index663, 8
  %309 = icmp eq i64 %index.next673, %n.vec658
  br i1 %309, label %middle.block653, label %vector.body662, !llvm.loop !43

middle.block653:                                  ; preds = %vector.body662
  %bin.rdx674 = add <4 x i32> %308, %307
  %310 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx674)
  %cmp.n661 = icmp eq i64 %n.vec658, %.pre399
  br i1 %cmp.n661, label %._crit_edge.us.us322.1, label %scalar.ph654.preheader

scalar.ph654.preheader:                           ; preds = %._crit_edge.us.us322, %middle.block653
  %indvars.iv362.1.ph = phi i64 [ 1, %._crit_edge.us.us322 ], [ %ind.end659, %middle.block653 ]
  %.4314.us.us.1.ph = phi i32 [ %spec.select300.us.us.lcssa, %._crit_edge.us.us322 ], [ %310, %middle.block653 ]
  br label %scalar.ph654

scalar.ph654:                                     ; preds = %scalar.ph654.preheader, %scalar.ph654
  %indvars.iv362.1 = phi i64 [ %indvars.iv.next363.1, %scalar.ph654 ], [ %indvars.iv362.1.ph, %scalar.ph654.preheader ]
  %.4314.us.us.1 = phi i32 [ %spec.select300.us.us.1, %scalar.ph654 ], [ %.4314.us.us.1.ph, %scalar.ph654.preheader ]
  %311 = add i64 %indvars.iv362.1, -1
  %312 = getelementptr i32, ptr %.unpack276.pre, i64 %311
  %313 = load i32, ptr %312, align 4, !tbaa !7
  %314 = icmp eq i32 %299, %313
  %315 = zext i1 %314 to i32
  %spec.select300.us.us.1 = add i32 %.4314.us.us.1, %315
  %indvars.iv.next363.1 = add nuw nsw i64 %indvars.iv362.1, 1
  %exitcond365.1.not = icmp eq i64 %indvars.iv362.1, %.pre399
  br i1 %exitcond365.1.not, label %._crit_edge.us.us322.1, label %scalar.ph654, !llvm.loop !44

._crit_edge.us.us322.1:                           ; preds = %scalar.ph654, %middle.block653
  %spec.select300.us.us.1.lcssa = phi i32 [ %310, %middle.block653 ], [ %spec.select300.us.us.1, %scalar.ph654 ]
  %316 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 2), align 8, !tbaa !7
  %min.iters.check678 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check678, label %scalar.ph677.preheader, label %vector.ph679

vector.ph679:                                     ; preds = %._crit_edge.us.us322.1
  %n.vec681 = and i64 %.pre399, -8
  %ind.end682 = or i64 %n.vec681, 1
  %317 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select300.us.us.1.lcssa, i64 0
  %broadcast.splatinsert692 = insertelement <4 x i32> poison, i32 %316, i64 0
  %broadcast.splat693 = shufflevector <4 x i32> %broadcast.splatinsert692, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert694 = insertelement <4 x i32> poison, i32 %316, i64 0
  %broadcast.splat695 = shufflevector <4 x i32> %broadcast.splatinsert694, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body685

vector.body685:                                   ; preds = %vector.body685, %vector.ph679
  %index686 = phi i64 [ 0, %vector.ph679 ], [ %index.next696, %vector.body685 ]
  %vec.phi687 = phi <4 x i32> [ %317, %vector.ph679 ], [ %324, %vector.body685 ]
  %vec.phi688 = phi <4 x i32> [ zeroinitializer, %vector.ph679 ], [ %325, %vector.body685 ]
  %318 = getelementptr i32, ptr %.unpack276.pre, i64 %index686
  %wide.load690 = load <4 x i32>, ptr %318, align 4, !tbaa !7
  %319 = getelementptr i32, ptr %318, i64 4
  %wide.load691 = load <4 x i32>, ptr %319, align 4, !tbaa !7
  %320 = icmp eq <4 x i32> %broadcast.splat693, %wide.load690
  %321 = icmp eq <4 x i32> %broadcast.splat695, %wide.load691
  %322 = zext <4 x i1> %320 to <4 x i32>
  %323 = zext <4 x i1> %321 to <4 x i32>
  %324 = add <4 x i32> %vec.phi687, %322
  %325 = add <4 x i32> %vec.phi688, %323
  %index.next696 = add nuw i64 %index686, 8
  %326 = icmp eq i64 %index.next696, %n.vec681
  br i1 %326, label %middle.block676, label %vector.body685, !llvm.loop !45

middle.block676:                                  ; preds = %vector.body685
  %bin.rdx697 = add <4 x i32> %325, %324
  %327 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx697)
  %cmp.n684 = icmp eq i64 %n.vec681, %.pre399
  br i1 %cmp.n684, label %._crit_edge.us.us322.2, label %scalar.ph677.preheader

scalar.ph677.preheader:                           ; preds = %._crit_edge.us.us322.1, %middle.block676
  %indvars.iv362.2.ph = phi i64 [ 1, %._crit_edge.us.us322.1 ], [ %ind.end682, %middle.block676 ]
  %.4314.us.us.2.ph = phi i32 [ %spec.select300.us.us.1.lcssa, %._crit_edge.us.us322.1 ], [ %327, %middle.block676 ]
  br label %scalar.ph677

scalar.ph677:                                     ; preds = %scalar.ph677.preheader, %scalar.ph677
  %indvars.iv362.2 = phi i64 [ %indvars.iv.next363.2, %scalar.ph677 ], [ %indvars.iv362.2.ph, %scalar.ph677.preheader ]
  %.4314.us.us.2 = phi i32 [ %spec.select300.us.us.2, %scalar.ph677 ], [ %.4314.us.us.2.ph, %scalar.ph677.preheader ]
  %328 = add i64 %indvars.iv362.2, -1
  %329 = getelementptr i32, ptr %.unpack276.pre, i64 %328
  %330 = load i32, ptr %329, align 4, !tbaa !7
  %331 = icmp eq i32 %316, %330
  %332 = zext i1 %331 to i32
  %spec.select300.us.us.2 = add i32 %.4314.us.us.2, %332
  %indvars.iv.next363.2 = add nuw nsw i64 %indvars.iv362.2, 1
  %exitcond365.2.not = icmp eq i64 %indvars.iv362.2, %.pre399
  br i1 %exitcond365.2.not, label %._crit_edge.us.us322.2, label %scalar.ph677, !llvm.loop !46

._crit_edge.us.us322.2:                           ; preds = %scalar.ph677, %middle.block676
  %spec.select300.us.us.2.lcssa = phi i32 [ %327, %middle.block676 ], [ %spec.select300.us.us.2, %scalar.ph677 ]
  %333 = icmp eq i32 %spec.select300.us.us.2.lcssa, 3
  br i1 %333, label %.split325.us, label %.preheader303.us.1

.split313.us:                                     ; preds = %._crit_edge.us.us.2.2, %._crit_edge.us.us.2.1, %._crit_edge.us.us.2
  %334 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 29)
  %335 = call i1 @_FortranAioOutputAscii(ptr %334, ptr nonnull @_QQcl.596573, i64 3)
  br label %433

.preheader:                                       ; preds = %._crit_edge.us.us322.2.2
  br i1 %22, label %.lr.ph327.us.preheader, label %._crit_edge.thread

.lr.ph327.us.preheader:                           ; preds = %.preheader
  %336 = load i32, ptr @_QFEa, align 16, !tbaa !7
  %min.iters.check839 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check839, label %scalar.ph838.preheader, label %vector.ph840

vector.ph840:                                     ; preds = %.lr.ph327.us.preheader
  %n.vec842 = and i64 %.pre399, -8
  %ind.end843 = or i64 %n.vec842, 1
  %broadcast.splatinsert853 = insertelement <4 x i32> poison, i32 %336, i64 0
  %broadcast.splat854 = shufflevector <4 x i32> %broadcast.splatinsert853, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert855 = insertelement <4 x i32> poison, i32 %336, i64 0
  %broadcast.splat856 = shufflevector <4 x i32> %broadcast.splatinsert855, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body846

vector.body846:                                   ; preds = %vector.body846, %vector.ph840
  %index847 = phi i64 [ 0, %vector.ph840 ], [ %index.next857, %vector.body846 ]
  %vec.phi848 = phi <4 x i32> [ zeroinitializer, %vector.ph840 ], [ %343, %vector.body846 ]
  %vec.phi849 = phi <4 x i32> [ zeroinitializer, %vector.ph840 ], [ %344, %vector.body846 ]
  %337 = getelementptr i32, ptr %.unpack276.pre, i64 %index847
  %wide.load851 = load <4 x i32>, ptr %337, align 4, !tbaa !7
  %338 = getelementptr i32, ptr %337, i64 4
  %wide.load852 = load <4 x i32>, ptr %338, align 4, !tbaa !7
  %339 = icmp eq <4 x i32> %broadcast.splat854, %wide.load851
  %340 = icmp eq <4 x i32> %broadcast.splat856, %wide.load852
  %341 = zext <4 x i1> %339 to <4 x i32>
  %342 = zext <4 x i1> %340 to <4 x i32>
  %343 = add <4 x i32> %vec.phi848, %341
  %344 = add <4 x i32> %vec.phi849, %342
  %index.next857 = add nuw i64 %index847, 8
  %345 = icmp eq i64 %index.next857, %n.vec842
  br i1 %345, label %middle.block837, label %vector.body846, !llvm.loop !47

middle.block837:                                  ; preds = %vector.body846
  %bin.rdx858 = add <4 x i32> %344, %343
  %346 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx858)
  %cmp.n845 = icmp eq i64 %n.vec842, %.pre399
  br i1 %cmp.n845, label %._crit_edge.us, label %scalar.ph838.preheader

scalar.ph838.preheader:                           ; preds = %.lr.ph327.us.preheader, %middle.block837
  %indvars.iv385.ph = phi i64 [ 1, %.lr.ph327.us.preheader ], [ %ind.end843, %middle.block837 ]
  %.7326.us.ph = phi i32 [ 0, %.lr.ph327.us.preheader ], [ %346, %middle.block837 ]
  br label %scalar.ph838

scalar.ph838:                                     ; preds = %scalar.ph838.preheader, %scalar.ph838
  %indvars.iv385 = phi i64 [ %indvars.iv.next386, %scalar.ph838 ], [ %indvars.iv385.ph, %scalar.ph838.preheader ]
  %.7326.us = phi i32 [ %spec.select301.us, %scalar.ph838 ], [ %.7326.us.ph, %scalar.ph838.preheader ]
  %347 = add i64 %indvars.iv385, -1
  %348 = getelementptr i32, ptr %.unpack276.pre, i64 %347
  %349 = load i32, ptr %348, align 4, !tbaa !7
  %350 = icmp eq i32 %336, %349
  %351 = zext i1 %350 to i32
  %spec.select301.us = add i32 %.7326.us, %351
  %indvars.iv.next386 = add nuw nsw i64 %indvars.iv385, 1
  %exitcond388.not = icmp eq i64 %indvars.iv385, %.pre399
  br i1 %exitcond388.not, label %._crit_edge.us, label %scalar.ph838, !llvm.loop !48

._crit_edge.us:                                   ; preds = %scalar.ph838, %middle.block837
  %spec.select301.us.lcssa = phi i32 [ %346, %middle.block837 ], [ %spec.select301.us, %scalar.ph838 ]
  %352 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 1), align 16, !tbaa !7
  %min.iters.check862 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check862, label %scalar.ph861.preheader, label %vector.ph863

vector.ph863:                                     ; preds = %._crit_edge.us
  %n.vec865 = and i64 %.pre399, -8
  %ind.end866 = or i64 %n.vec865, 1
  %353 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select301.us.lcssa, i64 0
  %broadcast.splatinsert876 = insertelement <4 x i32> poison, i32 %352, i64 0
  %broadcast.splat877 = shufflevector <4 x i32> %broadcast.splatinsert876, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert878 = insertelement <4 x i32> poison, i32 %352, i64 0
  %broadcast.splat879 = shufflevector <4 x i32> %broadcast.splatinsert878, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body869

vector.body869:                                   ; preds = %vector.body869, %vector.ph863
  %index870 = phi i64 [ 0, %vector.ph863 ], [ %index.next880, %vector.body869 ]
  %vec.phi871 = phi <4 x i32> [ %353, %vector.ph863 ], [ %360, %vector.body869 ]
  %vec.phi872 = phi <4 x i32> [ zeroinitializer, %vector.ph863 ], [ %361, %vector.body869 ]
  %354 = getelementptr i32, ptr %.unpack276.pre, i64 %index870
  %wide.load874 = load <4 x i32>, ptr %354, align 4, !tbaa !7
  %355 = getelementptr i32, ptr %354, i64 4
  %wide.load875 = load <4 x i32>, ptr %355, align 4, !tbaa !7
  %356 = icmp eq <4 x i32> %broadcast.splat877, %wide.load874
  %357 = icmp eq <4 x i32> %broadcast.splat879, %wide.load875
  %358 = zext <4 x i1> %356 to <4 x i32>
  %359 = zext <4 x i1> %357 to <4 x i32>
  %360 = add <4 x i32> %vec.phi871, %358
  %361 = add <4 x i32> %vec.phi872, %359
  %index.next880 = add nuw i64 %index870, 8
  %362 = icmp eq i64 %index.next880, %n.vec865
  br i1 %362, label %middle.block860, label %vector.body869, !llvm.loop !49

middle.block860:                                  ; preds = %vector.body869
  %bin.rdx881 = add <4 x i32> %361, %360
  %363 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx881)
  %cmp.n868 = icmp eq i64 %n.vec865, %.pre399
  br i1 %cmp.n868, label %._crit_edge.us.1, label %scalar.ph861.preheader

scalar.ph861.preheader:                           ; preds = %._crit_edge.us, %middle.block860
  %indvars.iv385.1.ph = phi i64 [ 1, %._crit_edge.us ], [ %ind.end866, %middle.block860 ]
  %.7326.us.1.ph = phi i32 [ %spec.select301.us.lcssa, %._crit_edge.us ], [ %363, %middle.block860 ]
  br label %scalar.ph861

scalar.ph861:                                     ; preds = %scalar.ph861.preheader, %scalar.ph861
  %indvars.iv385.1 = phi i64 [ %indvars.iv.next386.1, %scalar.ph861 ], [ %indvars.iv385.1.ph, %scalar.ph861.preheader ]
  %.7326.us.1 = phi i32 [ %spec.select301.us.1, %scalar.ph861 ], [ %.7326.us.1.ph, %scalar.ph861.preheader ]
  %364 = add i64 %indvars.iv385.1, -1
  %365 = getelementptr i32, ptr %.unpack276.pre, i64 %364
  %366 = load i32, ptr %365, align 4, !tbaa !7
  %367 = icmp eq i32 %352, %366
  %368 = zext i1 %367 to i32
  %spec.select301.us.1 = add i32 %.7326.us.1, %368
  %indvars.iv.next386.1 = add nuw nsw i64 %indvars.iv385.1, 1
  %exitcond388.1.not = icmp eq i64 %indvars.iv385.1, %.pre399
  br i1 %exitcond388.1.not, label %._crit_edge.us.1, label %scalar.ph861, !llvm.loop !50

._crit_edge.us.1:                                 ; preds = %scalar.ph861, %middle.block860
  %spec.select301.us.1.lcssa = phi i32 [ %363, %middle.block860 ], [ %spec.select301.us.1, %scalar.ph861 ]
  %369 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 2), align 16, !tbaa !7
  %min.iters.check885 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check885, label %scalar.ph884.preheader, label %vector.ph886

vector.ph886:                                     ; preds = %._crit_edge.us.1
  %n.vec888 = and i64 %.pre399, -8
  %ind.end889 = or i64 %n.vec888, 1
  %370 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %spec.select301.us.1.lcssa, i64 0
  %broadcast.splatinsert899 = insertelement <4 x i32> poison, i32 %369, i64 0
  %broadcast.splat900 = shufflevector <4 x i32> %broadcast.splatinsert899, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert901 = insertelement <4 x i32> poison, i32 %369, i64 0
  %broadcast.splat902 = shufflevector <4 x i32> %broadcast.splatinsert901, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body892

vector.body892:                                   ; preds = %vector.body892, %vector.ph886
  %index893 = phi i64 [ 0, %vector.ph886 ], [ %index.next903, %vector.body892 ]
  %vec.phi894 = phi <4 x i32> [ %370, %vector.ph886 ], [ %377, %vector.body892 ]
  %vec.phi895 = phi <4 x i32> [ zeroinitializer, %vector.ph886 ], [ %378, %vector.body892 ]
  %371 = getelementptr i32, ptr %.unpack276.pre, i64 %index893
  %wide.load897 = load <4 x i32>, ptr %371, align 4, !tbaa !7
  %372 = getelementptr i32, ptr %371, i64 4
  %wide.load898 = load <4 x i32>, ptr %372, align 4, !tbaa !7
  %373 = icmp eq <4 x i32> %broadcast.splat900, %wide.load897
  %374 = icmp eq <4 x i32> %broadcast.splat902, %wide.load898
  %375 = zext <4 x i1> %373 to <4 x i32>
  %376 = zext <4 x i1> %374 to <4 x i32>
  %377 = add <4 x i32> %vec.phi894, %375
  %378 = add <4 x i32> %vec.phi895, %376
  %index.next903 = add nuw i64 %index893, 8
  %379 = icmp eq i64 %index.next903, %n.vec888
  br i1 %379, label %middle.block883, label %vector.body892, !llvm.loop !51

middle.block883:                                  ; preds = %vector.body892
  %bin.rdx904 = add <4 x i32> %378, %377
  %380 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx904)
  %cmp.n891 = icmp eq i64 %n.vec888, %.pre399
  br i1 %cmp.n891, label %.split331.us, label %scalar.ph884.preheader

scalar.ph884.preheader:                           ; preds = %._crit_edge.us.1, %middle.block883
  %indvars.iv385.2.ph = phi i64 [ 1, %._crit_edge.us.1 ], [ %ind.end889, %middle.block883 ]
  %.7326.us.2.ph = phi i32 [ %spec.select301.us.1.lcssa, %._crit_edge.us.1 ], [ %380, %middle.block883 ]
  br label %scalar.ph884

scalar.ph884:                                     ; preds = %scalar.ph884.preheader, %scalar.ph884
  %indvars.iv385.2 = phi i64 [ %indvars.iv.next386.2, %scalar.ph884 ], [ %indvars.iv385.2.ph, %scalar.ph884.preheader ]
  %.7326.us.2 = phi i32 [ %spec.select301.us.2, %scalar.ph884 ], [ %.7326.us.2.ph, %scalar.ph884.preheader ]
  %381 = add i64 %indvars.iv385.2, -1
  %382 = getelementptr i32, ptr %.unpack276.pre, i64 %381
  %383 = load i32, ptr %382, align 4, !tbaa !7
  %384 = icmp eq i32 %369, %383
  %385 = zext i1 %384 to i32
  %spec.select301.us.2 = add i32 %.7326.us.2, %385
  %indvars.iv.next386.2 = add nuw nsw i64 %indvars.iv385.2, 1
  %exitcond388.2.not = icmp eq i64 %indvars.iv385.2, %.pre399
  br i1 %exitcond388.2.not, label %.split331.us, label %scalar.ph884, !llvm.loop !52

.split325.us:                                     ; preds = %._crit_edge.us.us322.2.2, %._crit_edge.us.us322.2.1, %._crit_edge.us.us322.2
  %386 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 44)
  %387 = call i1 @_FortranAioOutputAscii(ptr %386, ptr nonnull @_QQcl.596573, i64 3)
  br label %433

.split331.us:                                     ; preds = %scalar.ph884, %middle.block883
  %spec.select301.us.2.lcssa = phi i32 [ %380, %middle.block883 ], [ %spec.select301.us.2, %scalar.ph884 ]
  %388 = icmp eq i32 %spec.select301.us.2.lcssa, 3
  br i1 %388, label %389, label %392

389:                                              ; preds = %.split331.us
  %390 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 60)
  %391 = call i1 @_FortranAioOutputAscii(ptr %390, ptr nonnull @_QQcl.596573, i64 3)
  br label %433

392:                                              ; preds = %.split331.us
  br i1 %22, label %.lr.ph333, label %._crit_edge.thread

.lr.ph333:                                        ; preds = %392
  %393 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 2, i64 0), align 8, !tbaa !7
  %394 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 1, i64 1), align 16, !tbaa !7
  %395 = load i32, ptr getelementptr inbounds ([3 x [3 x i32]], ptr @_QFEa, i64 0, i64 0, i64 2), align 8, !tbaa !7
  %min.iters.check908 = icmp ult i32 %.pre, 8
  br i1 %min.iters.check908, label %scalar.ph907.preheader, label %vector.ph909

vector.ph909:                                     ; preds = %.lr.ph333
  %n.vec911 = and i64 %.pre399, -8
  %ind.end912 = or i64 %n.vec911, 1
  %broadcast.splatinsert922 = insertelement <4 x i32> poison, i32 %393, i64 0
  %broadcast.splat923 = shufflevector <4 x i32> %broadcast.splatinsert922, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert924 = insertelement <4 x i32> poison, i32 %393, i64 0
  %broadcast.splat925 = shufflevector <4 x i32> %broadcast.splatinsert924, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert926 = insertelement <4 x i32> poison, i32 %394, i64 0
  %broadcast.splat927 = shufflevector <4 x i32> %broadcast.splatinsert926, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert928 = insertelement <4 x i32> poison, i32 %394, i64 0
  %broadcast.splat929 = shufflevector <4 x i32> %broadcast.splatinsert928, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert930 = insertelement <4 x i32> poison, i32 %395, i64 0
  %broadcast.splat931 = shufflevector <4 x i32> %broadcast.splatinsert930, <4 x i32> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert932 = insertelement <4 x i32> poison, i32 %395, i64 0
  %broadcast.splat933 = shufflevector <4 x i32> %broadcast.splatinsert932, <4 x i32> poison, <4 x i32> zeroinitializer
  br label %vector.body915

vector.body915:                                   ; preds = %vector.body915, %vector.ph909
  %index916 = phi i64 [ 0, %vector.ph909 ], [ %index.next934, %vector.body915 ]
  %vec.phi917 = phi <4 x i32> [ zeroinitializer, %vector.ph909 ], [ %414, %vector.body915 ]
  %vec.phi918 = phi <4 x i32> [ zeroinitializer, %vector.ph909 ], [ %415, %vector.body915 ]
  %396 = getelementptr i32, ptr %.unpack276.pre, i64 %index916
  %wide.load920 = load <4 x i32>, ptr %396, align 4, !tbaa !7
  %397 = getelementptr i32, ptr %396, i64 4
  %wide.load921 = load <4 x i32>, ptr %397, align 4, !tbaa !7
  %398 = icmp eq <4 x i32> %broadcast.splat923, %wide.load920
  %399 = icmp eq <4 x i32> %broadcast.splat925, %wide.load921
  %400 = zext <4 x i1> %398 to <4 x i32>
  %401 = zext <4 x i1> %399 to <4 x i32>
  %402 = add <4 x i32> %vec.phi917, %400
  %403 = add <4 x i32> %vec.phi918, %401
  %404 = icmp eq <4 x i32> %broadcast.splat927, %wide.load920
  %405 = icmp eq <4 x i32> %broadcast.splat929, %wide.load921
  %406 = zext <4 x i1> %404 to <4 x i32>
  %407 = zext <4 x i1> %405 to <4 x i32>
  %408 = add <4 x i32> %402, %406
  %409 = add <4 x i32> %403, %407
  %410 = icmp eq <4 x i32> %broadcast.splat931, %wide.load920
  %411 = icmp eq <4 x i32> %broadcast.splat933, %wide.load921
  %412 = zext <4 x i1> %410 to <4 x i32>
  %413 = zext <4 x i1> %411 to <4 x i32>
  %414 = add <4 x i32> %408, %412
  %415 = add <4 x i32> %409, %413
  %index.next934 = add nuw i64 %index916, 8
  %416 = icmp eq i64 %index.next934, %n.vec911
  br i1 %416, label %middle.block906, label %vector.body915, !llvm.loop !53

middle.block906:                                  ; preds = %vector.body915
  %bin.rdx935 = add <4 x i32> %415, %414
  %417 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %bin.rdx935)
  %cmp.n914 = icmp eq i64 %n.vec911, %.pre399
  br i1 %cmp.n914, label %._crit_edge, label %scalar.ph907.preheader

scalar.ph907.preheader:                           ; preds = %.lr.ph333, %middle.block906
  %indvars.iv393.ph = phi i64 [ 1, %.lr.ph333 ], [ %ind.end912, %middle.block906 ]
  %.9332.ph = phi i32 [ 0, %.lr.ph333 ], [ %417, %middle.block906 ]
  br label %scalar.ph907

scalar.ph907:                                     ; preds = %scalar.ph907.preheader, %scalar.ph907
  %indvars.iv393 = phi i64 [ %indvars.iv.next394, %scalar.ph907 ], [ %indvars.iv393.ph, %scalar.ph907.preheader ]
  %.9332 = phi i32 [ %.12, %scalar.ph907 ], [ %.9332.ph, %scalar.ph907.preheader ]
  %418 = add i64 %indvars.iv393, -1
  %419 = getelementptr i32, ptr %.unpack276.pre, i64 %418
  %420 = load i32, ptr %419, align 4, !tbaa !7
  %421 = icmp eq i32 %393, %420
  %422 = zext i1 %421 to i32
  %spec.select302 = add i32 %.9332, %422
  %423 = icmp eq i32 %394, %420
  %424 = zext i1 %423 to i32
  %.11 = add i32 %spec.select302, %424
  %425 = icmp eq i32 %395, %420
  %426 = zext i1 %425 to i32
  %.12 = add i32 %.11, %426
  %indvars.iv.next394 = add nuw nsw i64 %indvars.iv393, 1
  %exitcond396.not = icmp eq i64 %indvars.iv393, %.pre399
  br i1 %exitcond396.not, label %._crit_edge, label %scalar.ph907, !llvm.loop !54

._crit_edge:                                      ; preds = %scalar.ph907, %middle.block906
  %.12.lcssa = phi i32 [ %417, %middle.block906 ], [ %.12, %scalar.ph907 ]
  %427 = icmp eq i32 %.12.lcssa, 3
  br i1 %427, label %428, label %._crit_edge.thread

428:                                              ; preds = %._crit_edge
  %429 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 81)
  %430 = call i1 @_FortranAioOutputAscii(ptr %429, ptr nonnull @_QQcl.596573, i64 3)
  br label %433

._crit_edge.thread:                               ; preds = %.preheader, %.preheader304, %0, %.preheader306, %392, %._crit_edge
  %431 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.8be76318bc2fce4006217a94205be1be, i32 85)
  %432 = call i1 @_FortranAioOutputAscii(ptr %431, ptr nonnull @_QQcl.4E6F, i64 2)
  br label %433

433:                                              ; preds = %.split313.us, %.split325.us, %389, %428, %._crit_edge.thread
  %.sink = phi ptr [ %334, %.split313.us ], [ %386, %.split325.us ], [ %390, %389 ], [ %429, %428 ], [ %431, %._crit_edge.thread ]
  %434 = call i32 @_FortranAioEndIoStatement(ptr %.sink)
  ret void
}

declare ptr @_FortranAioBeginExternalListInput(i32, ptr, i32) local_unnamed_addr

declare i1 @_FortranAioInputDescriptor(ptr, ptr) local_unnamed_addr

declare i32 @_FortranAioEndIoStatement(ptr) local_unnamed_addr

declare i1 @_FortranAioInputInteger(ptr, ptr, i32) local_unnamed_addr

declare ptr @_FortranAioBeginExternalListOutput(i32, ptr, i32) local_unnamed_addr

declare i1 @_FortranAioOutputAscii(ptr, ptr, i64) local_unnamed_addr

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.smax.i32(i32, i32) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i32 @llvm.vector.reduce.add.v4i32(<4 x i32>) #2

attributes #0 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { nocallback nofree nosync nounwind willreturn memory(none) }

!llvm.module.flags = !{!0, !1, !2}

!0 = !{i32 2, !"Debug Info Version", i32 3}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{!4, !4, i64 0}
!4 = !{!"descriptor member", !5, i64 0}
!5 = !{!"any access", !6, i64 0}
!6 = !{!"Flang Type TBAA Root"}
!7 = !{!8, !8, i64 0}
!8 = !{!"any data access", !5, i64 0}
!9 = distinct !{!9, !10, !11}
!10 = !{!"llvm.loop.isvectorized", i32 1}
!11 = !{!"llvm.loop.unroll.runtime.disable"}
!12 = distinct !{!12, !10, !11}
!13 = distinct !{!13, !11, !10}
!14 = distinct !{!14, !10, !11}
!15 = distinct !{!15, !11, !10}
!16 = distinct !{!16, !10, !11}
!17 = distinct !{!17, !11, !10}
!18 = distinct !{!18, !10, !11}
!19 = distinct !{!19, !11, !10}
!20 = distinct !{!20, !10, !11}
!21 = distinct !{!21, !11, !10}
!22 = distinct !{!22, !10, !11}
!23 = distinct !{!23, !11, !10}
!24 = distinct !{!24, !11, !10}
!25 = distinct !{!25, !10, !11}
!26 = distinct !{!26, !11, !10}
!27 = distinct !{!27, !10, !11}
!28 = distinct !{!28, !11, !10}
!29 = distinct !{!29, !10, !11}
!30 = distinct !{!30, !10, !11}
!31 = distinct !{!31, !11, !10}
!32 = distinct !{!32, !10, !11}
!33 = distinct !{!33, !11, !10}
!34 = distinct !{!34, !10, !11}
!35 = distinct !{!35, !11, !10}
!36 = distinct !{!36, !10, !11}
!37 = distinct !{!37, !11, !10}
!38 = distinct !{!38, !10, !11}
!39 = distinct !{!39, !11, !10}
!40 = distinct !{!40, !10, !11}
!41 = distinct !{!41, !11, !10}
!42 = distinct !{!42, !11, !10}
!43 = distinct !{!43, !10, !11}
!44 = distinct !{!44, !11, !10}
!45 = distinct !{!45, !10, !11}
!46 = distinct !{!46, !11, !10}
!47 = distinct !{!47, !10, !11}
!48 = distinct !{!48, !11, !10}
!49 = distinct !{!49, !10, !11}
!50 = distinct !{!50, !11, !10}
!51 = distinct !{!51, !10, !11}
!52 = distinct !{!52, !11, !10}
!53 = distinct !{!53, !10, !11}
!54 = distinct !{!54, !11, !10}
