program align
  implicit none
  integer              :: n, i
  integer, allocatable :: a(:)
  integer(8)           :: m1, m2, m3, m4
  read(*,*) n
  allocate(a(n))
  do i = 1, n
     read(*,*) a(i)
  end do
  if (n .eq. 2) then
     write(*,'(i0)') abs(a(1)-a(2))
     stop
  end if
  call merge_sort(n,a)
  m1 = 0
  m2 = 0
  m3 = 0
  m4 = 0
  if (mod(n,2) .eq. 1) then
     do i = 1, n/2
        m1 = m1 + abs(a(i)-a(n+1-i))
        m2 = m2 + abs(a(n+1-i)-a(i))
     end do
     do i = 1, n/2-1
        m1 = m1 + abs(a(n+1-i)-a(i+1))
        m2 = m2 + abs(a(i)-a(n-i))
     end do
     m1 = m1 + abs(a(1)-a(n/2+1))
     m2 = m2 + abs(a(n)-a(n/2+1))
  else
     do i = 1, n/2-1
        m1 = m1 + abs(a(i)-a(n+1-i))
        m2 = m2 + abs(a(n+1-i)-a(i))
     end do
     if (n .gt. 4) then
        do i = 1, n/2-2
           m1 = m1 + abs(a(n+1-i)-a(i+1))
           m2 = m2 + abs(a(i)-a(n-i))
        end do
     end if
     m3 = m1 + abs(a(n/2)-a(1)) + abs(a(n/2+2)-a(n/2+1))
     m4 = m2 + abs(a(n/2)-a(n)) + abs(a(n/2-1)-a(n/2+1))
     m1 = m1 + abs(a(n/2+1)-a(1)) + abs(a(n/2+2)-a(n/2))
     m2 = m2 + abs(a(n/2+1)-a(n)) + abs(a(n/2-1)-a(n/2))
     m1 = max(m1,m3)
     m2 = max(m2,m4)
  end if
  write(*,'(i0)') max(m1,m2)
  deallocate(a)
  stop
contains
  subroutine merge_sort(n,c)
    implicit none
    integer, intent(in)    :: n
    integer, intent(inout) :: c(n)
    integer                :: number, length, i, ubound
    number = n
    length = 1
    do while (number .gt. 1)
       do i = 1, number/2
          ubound = min(2*i*length,n)
          call merge(c(2*(i-1)*length+1:(2*i-1)*length),c((2*i-1)*length+1:ubound))
       end do
       length = 2*length
       number = (number+1)/2
    end do
    return
  end subroutine merge_sort

  subroutine merge(c1,c2)
    implicit none
    integer, intent(inout) :: c1(:), c2(:)
    integer                :: c(size(c1)+size(c2))
    integer                :: i1, i2, n1, n2
    i1 = 1
    i2 = 1
    n1 = size(c1)
    n2 = size(c2)
    do while (i1 .le. n1 .and. i2 .le. n2)
       if (c1(i1) .lt. c2(i2)) then
          c(i1+i2-1) = c1(i1)
          i1 = i1+1
       else
          c(i1+i2-1) = c2(i2)
          i2 = i2+1
       end if
    end do
    if (i1 .le. n1) then
       c(i1+i2-1:n1+n2) = c1(i1:n1)
    else if (i2 .le. n2) then
       c(i1+i2-1:n1+n2) = c2(i2:n2)
    end if
    c1 = c(1:n1)
    c2 = c(n1+1:n1+n2)
    return
  end subroutine merge

  subroutine swap(a,b)
    implicit none
    integer, intent(inout) :: a, b
    integer                :: c
    c = a
    a = b
    b = c
    return
  end subroutine swap
end program align
; 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.0 = internal unnamed_addr global ptr null
@_QQcl.2f826bb354df98b62ff159f5fe31cff0 = linkonce constant [73 x i8] c"/home/ubuntu/Downloads/TheStack_IR/Collated/Fortran/Source_5423/source.f\00"
@_QQcl.28693029 = linkonce constant [4 x i8] c"(i0)"
@_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

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #1

; Function Attrs: noreturn
define void @_QQmain() local_unnamed_addr #2 {
  %1 = alloca i32, align 4
  %2 = tail call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.2f826bb354df98b62ff159f5fe31cff0, i32 6)
  %3 = call i1 @_FortranAioInputInteger(ptr %2, ptr nonnull %1, i32 4)
  %4 = call i32 @_FortranAioEndIoStatement(ptr %2)
  %5 = load i32, ptr %1, align 4, !tbaa !3
  %6 = call i32 @llvm.smax.i32(i32 %5, i32 0)
  %7 = zext i32 %6 to i64
  %8 = shl nuw nsw i64 %7, 2
  %9 = call ptr @malloc(i64 %8)
  store ptr %9, ptr @_QFEa.0, align 8, !tbaa !7
  %10 = icmp sgt i32 %5, 0
  br i1 %10, label %.lr.ph.preheader, label %._crit_edge.thread

.lr.ph.preheader:                                 ; preds = %0
  %11 = zext i32 %5 to i64
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv = phi i64 [ 1, %.lr.ph.preheader ], [ %indvars.iv.next, %.lr.ph ]
  %12 = call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.2f826bb354df98b62ff159f5fe31cff0, i32 9)
  %.unpack558 = load ptr, ptr @_QFEa.0, align 8, !tbaa !7
  %13 = add nsw i64 %indvars.iv, -1
  %14 = getelementptr i32, ptr %.unpack558, i64 %13
  %15 = call i1 @_FortranAioInputInteger(ptr %12, ptr %14, i32 4)
  %16 = call i32 @_FortranAioEndIoStatement(ptr %12)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv, %11
  br i1 %exitcond.not, label %._crit_edge, label %.lr.ph

._crit_edge:                                      ; preds = %.lr.ph
  %.pre = load i32, ptr %1, align 4, !tbaa !3
  %17 = icmp eq i32 %.pre, 2
  br i1 %17, label %18, label %._crit_edge.thread

18:                                               ; preds = %._crit_edge
  %19 = call ptr @_FortranAioBeginExternalFormattedOutput(ptr nonnull @_QQcl.28693029, i64 4, ptr null, i32 -1, ptr nonnull @_QQcl.2f826bb354df98b62ff159f5fe31cff0, i32 12)
  %.unpack546 = load ptr, ptr @_QFEa.0, align 8, !tbaa !7
  %20 = load i32, ptr %.unpack546, align 4, !tbaa !3
  %21 = getelementptr i32, ptr %.unpack546, i64 1
  %22 = load i32, ptr %21, align 4, !tbaa !3
  %23 = sub i32 %20, %22
  %24 = call i32 @llvm.abs.i32(i32 %23, i1 false)
  %25 = call i1 @_FortranAioOutputInteger32(ptr %19, i32 %24)
  %26 = call i32 @_FortranAioEndIoStatement(ptr %19)
  %27 = call {} @_FortranAStopStatement(i32 0, i1 false, i1 false)
  unreachable

._crit_edge.thread:                               ; preds = %0, %._crit_edge
  %.unpack = load ptr, ptr @_QFEa.0, align 8, !tbaa !7
  call void @_QFPmerge_sort(ptr nonnull %1, ptr %.unpack)
  %28 = load i32, ptr %1, align 4, !tbaa !3
  %29 = and i32 %28, -2147483647
  %30 = icmp eq i32 %29, 1
  br i1 %30, label %31, label %192

31:                                               ; preds = %._crit_edge.thread
  %32 = lshr i32 %28, 1
  %.not599 = icmp ult i32 %28, 2
  br i1 %.not599, label %._crit_edge596, label %.lr.ph588

.lr.ph588:                                        ; preds = %31
  %33 = zext i32 %32 to i64
  %34 = add nuw i32 %28, 1
  %min.iters.check701 = icmp ult i32 %28, 12
  br i1 %min.iters.check701, label %scalar.ph700.preheader, label %vector.scevcheck694

vector.scevcheck694:                              ; preds = %.lr.ph588
  %35 = add nsw i64 %33, -1
  %36 = trunc i64 %35 to i32
  %37 = sub i32 %28, %36
  %38 = icmp sgt i32 %37, %28
  %39 = icmp ugt i64 %35, 4294967295
  %40 = or i1 %38, %39
  br i1 %40, label %scalar.ph700.preheader, label %vector.ph702

vector.ph702:                                     ; preds = %vector.scevcheck694
  %n.vec704 = and i64 %33, 2147483644
  %ind.end705 = or i64 %n.vec704, 1
  %ind.end707 = and i64 %33, 3
  br label %vector.body710

vector.body710:                                   ; preds = %vector.body710, %vector.ph702
  %index711 = phi i64 [ 0, %vector.ph702 ], [ %index.next724, %vector.body710 ]
  %vec.phi712 = phi <2 x i64> [ zeroinitializer, %vector.ph702 ], [ %65, %vector.body710 ]
  %vec.phi713 = phi <2 x i64> [ zeroinitializer, %vector.ph702 ], [ %66, %vector.body710 ]
  %vec.phi714 = phi <2 x i64> [ zeroinitializer, %vector.ph702 ], [ %57, %vector.body710 ]
  %vec.phi715 = phi <2 x i64> [ zeroinitializer, %vector.ph702 ], [ %58, %vector.body710 ]
  %41 = trunc i64 %index711 to i32
  %42 = getelementptr i32, ptr %.unpack, i64 %index711
  %wide.load718 = load <2 x i32>, ptr %42, align 4, !tbaa !3
  %43 = getelementptr i32, ptr %42, i64 2
  %wide.load719 = load <2 x i32>, ptr %43, align 4, !tbaa !3
  %44 = sub i32 %28, %41
  %45 = sext i32 %44 to i64
  %46 = add nsw i64 %45, -1
  %47 = getelementptr i32, ptr %.unpack, i64 %46
  %48 = getelementptr i32, ptr %47, i64 -1
  %wide.load720 = load <2 x i32>, ptr %48, align 4, !tbaa !3
  %reverse721 = shufflevector <2 x i32> %wide.load720, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %49 = getelementptr i32, ptr %47, i64 -2
  %50 = getelementptr i32, ptr %49, i64 -1
  %wide.load722 = load <2 x i32>, ptr %50, align 4, !tbaa !3
  %reverse723 = shufflevector <2 x i32> %wide.load722, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %51 = sub <2 x i32> %wide.load718, %reverse721
  %52 = sub <2 x i32> %wide.load719, %reverse723
  %53 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %51, i1 false)
  %54 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %52, i1 false)
  %55 = sext <2 x i32> %53 to <2 x i64>
  %56 = sext <2 x i32> %54 to <2 x i64>
  %57 = add <2 x i64> %vec.phi714, %55
  %58 = add <2 x i64> %vec.phi715, %56
  %59 = sub <2 x i32> %reverse721, %wide.load718
  %60 = sub <2 x i32> %reverse723, %wide.load719
  %61 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %59, i1 false)
  %62 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %60, i1 false)
  %63 = sext <2 x i32> %61 to <2 x i64>
  %64 = sext <2 x i32> %62 to <2 x i64>
  %65 = add <2 x i64> %vec.phi712, %63
  %66 = add <2 x i64> %vec.phi713, %64
  %index.next724 = add nuw i64 %index711, 4
  %67 = icmp eq i64 %index.next724, %n.vec704
  br i1 %67, label %middle.block699, label %vector.body710, !llvm.loop !9

middle.block699:                                  ; preds = %vector.body710
  %bin.rdx727 = add <2 x i64> %58, %57
  %68 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx727)
  %bin.rdx725 = add <2 x i64> %66, %65
  %69 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx725)
  %cmp.n709 = icmp eq i64 %n.vec704, %33
  br i1 %cmp.n709, label %._crit_edge589, label %scalar.ph700.preheader

scalar.ph700.preheader:                           ; preds = %vector.scevcheck694, %.lr.ph588, %middle.block699
  %indvars.iv611.ph = phi i64 [ 1, %vector.scevcheck694 ], [ 1, %.lr.ph588 ], [ %ind.end705, %middle.block699 ]
  %.ph783 = phi i64 [ %33, %vector.scevcheck694 ], [ %33, %.lr.ph588 ], [ %ind.end707, %middle.block699 ]
  %.0586.ph = phi i64 [ 0, %vector.scevcheck694 ], [ 0, %.lr.ph588 ], [ %69, %middle.block699 ]
  %.0430585.ph = phi i64 [ 0, %vector.scevcheck694 ], [ 0, %.lr.ph588 ], [ %68, %middle.block699 ]
  br label %scalar.ph700

scalar.ph700:                                     ; preds = %scalar.ph700.preheader, %scalar.ph700
  %indvars.iv611 = phi i64 [ %indvars.iv.next612, %scalar.ph700 ], [ %indvars.iv611.ph, %scalar.ph700.preheader ]
  %70 = phi i64 [ %88, %scalar.ph700 ], [ %.ph783, %scalar.ph700.preheader ]
  %.0586 = phi i64 [ %87, %scalar.ph700 ], [ %.0586.ph, %scalar.ph700.preheader ]
  %.0430585 = phi i64 [ %83, %scalar.ph700 ], [ %.0430585.ph, %scalar.ph700.preheader ]
  %71 = add i64 %indvars.iv611, -1
  %72 = getelementptr i32, ptr %.unpack, i64 %71
  %73 = load i32, ptr %72, align 4, !tbaa !3
  %74 = trunc i64 %indvars.iv611 to i32
  %75 = sub i32 %34, %74
  %76 = sext i32 %75 to i64
  %77 = add nsw i64 %76, -1
  %78 = getelementptr i32, ptr %.unpack, i64 %77
  %79 = load i32, ptr %78, align 4, !tbaa !3
  %80 = sub i32 %73, %79
  %81 = call i32 @llvm.abs.i32(i32 %80, i1 false)
  %82 = sext i32 %81 to i64
  %83 = add i64 %.0430585, %82
  %84 = sub i32 %79, %73
  %85 = call i32 @llvm.abs.i32(i32 %84, i1 false)
  %86 = sext i32 %85 to i64
  %87 = add i64 %.0586, %86
  %indvars.iv.next612 = add nuw nsw i64 %indvars.iv611, 1
  %88 = add nsw i64 %70, -1
  %89 = icmp ugt i64 %70, 1
  br i1 %89, label %scalar.ph700, label %._crit_edge589, !llvm.loop !12

._crit_edge589:                                   ; preds = %scalar.ph700, %middle.block699
  %.lcssa633 = phi i64 [ %68, %middle.block699 ], [ %83, %scalar.ph700 ]
  %.lcssa632 = phi i64 [ %69, %middle.block699 ], [ %87, %scalar.ph700 ]
  %90 = icmp ugt i32 %28, 3
  br i1 %90, label %.lr.ph595, label %._crit_edge596

.lr.ph595:                                        ; preds = %._crit_edge589
  %91 = add nsw i32 %32, -1
  %92 = sext i32 %91 to i64
  %93 = add i32 %28, 1
  %smin737 = call i64 @llvm.smin.i64(i64 %92, i64 1)
  %94 = sub i64 %33, %smin737
  %min.iters.check740 = icmp ult i64 %94, 10
  br i1 %min.iters.check740, label %scalar.ph739.preheader, label %vector.scevcheck729

vector.scevcheck729:                              ; preds = %.lr.ph595
  %smin730 = call i64 @llvm.smin.i64(i64 %92, i64 1)
  %95 = xor i64 %smin730, -1
  %96 = add i64 %95, %33
  %97 = trunc i64 %96 to i32
  %98 = sub i32 %28, %97
  %99 = icmp sgt i32 %98, %28
  %100 = add i32 %28, -1
  %101 = trunc i64 %96 to i32
  %102 = sub i32 %100, %101
  %103 = icmp sgt i32 %102, %100
  %104 = icmp ugt i64 %96, 4294967295
  %105 = or i1 %103, %104
  %106 = or i1 %99, %105
  br i1 %106, label %scalar.ph739.preheader, label %vector.ph741

vector.ph741:                                     ; preds = %vector.scevcheck729
  %n.vec743 = and i64 %94, -4
  %ind.end744 = or i64 %n.vec743, 1
  %ind.end746 = sub i64 %92, %n.vec743
  %107 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %.lcssa632, i64 0
  %108 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %.lcssa633, i64 0
  br label %vector.body749

vector.body749:                                   ; preds = %vector.body749, %vector.ph741
  %index750 = phi i64 [ 0, %vector.ph741 ], [ %index.next769, %vector.body749 ]
  %vec.phi751 = phi <2 x i64> [ %107, %vector.ph741 ], [ %144, %vector.body749 ]
  %vec.phi752 = phi <2 x i64> [ zeroinitializer, %vector.ph741 ], [ %145, %vector.body749 ]
  %vec.phi753 = phi <2 x i64> [ %108, %vector.ph741 ], [ %127, %vector.body749 ]
  %vec.phi754 = phi <2 x i64> [ zeroinitializer, %vector.ph741 ], [ %128, %vector.body749 ]
  %109 = trunc i64 %index750 to i32
  %110 = or i32 %109, 1
  %111 = sub i32 %93, %110
  %112 = sext i32 %111 to i64
  %113 = add nsw i64 %112, -1
  %114 = getelementptr i32, ptr %.unpack, i64 %113
  %115 = getelementptr i32, ptr %114, i64 -1
  %wide.load757 = load <2 x i32>, ptr %115, align 4, !tbaa !3
  %reverse758 = shufflevector <2 x i32> %wide.load757, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %116 = getelementptr i32, ptr %114, i64 -2
  %117 = getelementptr i32, ptr %116, i64 -1
  %wide.load759 = load <2 x i32>, ptr %117, align 4, !tbaa !3
  %reverse760 = shufflevector <2 x i32> %wide.load759, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %118 = or i64 %index750, 1
  %119 = getelementptr i32, ptr %.unpack, i64 %118
  %wide.load761 = load <2 x i32>, ptr %119, align 4, !tbaa !3
  %120 = getelementptr i32, ptr %119, i64 2
  %wide.load762 = load <2 x i32>, ptr %120, align 4, !tbaa !3
  %121 = sub <2 x i32> %reverse758, %wide.load761
  %122 = sub <2 x i32> %reverse760, %wide.load762
  %123 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %121, i1 false)
  %124 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %122, i1 false)
  %125 = sext <2 x i32> %123 to <2 x i64>
  %126 = sext <2 x i32> %124 to <2 x i64>
  %127 = add <2 x i64> %vec.phi753, %125
  %128 = add <2 x i64> %vec.phi754, %126
  %129 = getelementptr i32, ptr %.unpack, i64 %index750
  %wide.load763 = load <2 x i32>, ptr %129, align 4, !tbaa !3
  %130 = getelementptr i32, ptr %129, i64 2
  %wide.load764 = load <2 x i32>, ptr %130, align 4, !tbaa !3
  %131 = sub i32 %28, %110
  %132 = sext i32 %131 to i64
  %133 = add nsw i64 %132, -1
  %134 = getelementptr i32, ptr %.unpack, i64 %133
  %135 = getelementptr i32, ptr %134, i64 -1
  %wide.load765 = load <2 x i32>, ptr %135, align 4, !tbaa !3
  %reverse766 = shufflevector <2 x i32> %wide.load765, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %136 = getelementptr i32, ptr %134, i64 -2
  %137 = getelementptr i32, ptr %136, i64 -1
  %wide.load767 = load <2 x i32>, ptr %137, align 4, !tbaa !3
  %reverse768 = shufflevector <2 x i32> %wide.load767, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %138 = sub <2 x i32> %wide.load763, %reverse766
  %139 = sub <2 x i32> %wide.load764, %reverse768
  %140 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %138, i1 false)
  %141 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %139, i1 false)
  %142 = sext <2 x i32> %140 to <2 x i64>
  %143 = sext <2 x i32> %141 to <2 x i64>
  %144 = add <2 x i64> %vec.phi751, %142
  %145 = add <2 x i64> %vec.phi752, %143
  %index.next769 = add nuw i64 %index750, 4
  %146 = icmp eq i64 %index.next769, %n.vec743
  br i1 %146, label %middle.block738, label %vector.body749, !llvm.loop !13

middle.block738:                                  ; preds = %vector.body749
  %bin.rdx772 = add <2 x i64> %128, %127
  %147 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx772)
  %bin.rdx770 = add <2 x i64> %145, %144
  %148 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx770)
  %cmp.n748 = icmp eq i64 %94, %n.vec743
  br i1 %cmp.n748, label %._crit_edge596, label %scalar.ph739.preheader

scalar.ph739.preheader:                           ; preds = %vector.scevcheck729, %.lr.ph595, %middle.block738
  %indvars.iv614.ph = phi i64 [ 1, %vector.scevcheck729 ], [ 1, %.lr.ph595 ], [ %ind.end744, %middle.block738 ]
  %.ph = phi i64 [ %92, %vector.scevcheck729 ], [ %92, %.lr.ph595 ], [ %ind.end746, %middle.block738 ]
  %.1593.ph = phi i64 [ %.lcssa632, %vector.scevcheck729 ], [ %.lcssa632, %.lr.ph595 ], [ %148, %middle.block738 ]
  %.1431592.ph = phi i64 [ %.lcssa633, %vector.scevcheck729 ], [ %.lcssa633, %.lr.ph595 ], [ %147, %middle.block738 ]
  br label %scalar.ph739

scalar.ph739:                                     ; preds = %scalar.ph739.preheader, %scalar.ph739
  %indvars.iv614 = phi i64 [ %indvars.iv.next615, %scalar.ph739 ], [ %indvars.iv614.ph, %scalar.ph739.preheader ]
  %149 = phi i64 [ %174, %scalar.ph739 ], [ %.ph, %scalar.ph739.preheader ]
  %.1593 = phi i64 [ %173, %scalar.ph739 ], [ %.1593.ph, %scalar.ph739.preheader ]
  %.1431592 = phi i64 [ %161, %scalar.ph739 ], [ %.1431592.ph, %scalar.ph739.preheader ]
  %150 = trunc i64 %indvars.iv614 to i32
  %151 = sub i32 %93, %150
  %152 = sext i32 %151 to i64
  %153 = add nsw i64 %152, -1
  %154 = getelementptr i32, ptr %.unpack, i64 %153
  %155 = load i32, ptr %154, align 4, !tbaa !3
  %indvars.iv.next615 = add nuw nsw i64 %indvars.iv614, 1
  %156 = getelementptr i32, ptr %.unpack, i64 %indvars.iv614
  %157 = load i32, ptr %156, align 4, !tbaa !3
  %158 = sub i32 %155, %157
  %159 = call i32 @llvm.abs.i32(i32 %158, i1 false)
  %160 = sext i32 %159 to i64
  %161 = add i64 %.1431592, %160
  %162 = add i64 %indvars.iv614, -1
  %163 = getelementptr i32, ptr %.unpack, i64 %162
  %164 = load i32, ptr %163, align 4, !tbaa !3
  %165 = sub i32 %28, %150
  %166 = sext i32 %165 to i64
  %167 = add nsw i64 %166, -1
  %168 = getelementptr i32, ptr %.unpack, i64 %167
  %169 = load i32, ptr %168, align 4, !tbaa !3
  %170 = sub i32 %164, %169
  %171 = call i32 @llvm.abs.i32(i32 %170, i1 false)
  %172 = sext i32 %171 to i64
  %173 = add i64 %.1593, %172
  %174 = add nsw i64 %149, -1
  %175 = icmp sgt i64 %149, 1
  br i1 %175, label %scalar.ph739, label %._crit_edge596, !llvm.loop !14

._crit_edge596:                                   ; preds = %scalar.ph739, %middle.block738, %._crit_edge589, %31
  %.1431.lcssa = phi i64 [ %.lcssa633, %._crit_edge589 ], [ 0, %31 ], [ %147, %middle.block738 ], [ %161, %scalar.ph739 ]
  %.1.lcssa = phi i64 [ %.lcssa632, %._crit_edge589 ], [ 0, %31 ], [ %148, %middle.block738 ], [ %173, %scalar.ph739 ]
  %176 = load i32, ptr %.unpack, align 4, !tbaa !3
  %177 = zext i32 %32 to i64
  %178 = getelementptr i32, ptr %.unpack, i64 %177
  %179 = load i32, ptr %178, align 4, !tbaa !3
  %180 = sub i32 %176, %179
  %181 = call i32 @llvm.abs.i32(i32 %180, i1 false)
  %182 = sext i32 %181 to i64
  %183 = add i64 %.1431.lcssa, %182
  %184 = sext i32 %28 to i64
  %185 = add nsw i64 %184, -1
  %186 = getelementptr i32, ptr %.unpack, i64 %185
  %187 = load i32, ptr %186, align 4, !tbaa !3
  %188 = sub i32 %187, %179
  %189 = call i32 @llvm.abs.i32(i32 %188, i1 false)
  %190 = sext i32 %189 to i64
  %191 = add i64 %.1.lcssa, %190
  br label %403

192:                                              ; preds = %._crit_edge.thread
  %193 = sdiv i32 %28, 2
  %194 = add nsw i32 %193, -1
  %195 = sext i32 %194 to i64
  %196 = icmp sgt i32 %28, 3
  br i1 %196, label %.lr.ph576, label %.loopexit

.lr.ph576:                                        ; preds = %192
  %197 = add nuw i32 %28, 1
  %198 = sext i32 %193 to i64
  %smin638 = call i64 @llvm.smin.i64(i64 %195, i64 1)
  %199 = sub i64 %198, %smin638
  %min.iters.check = icmp ult i64 %199, 8
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %.lr.ph576
  %narrow775 = add nsw i32 %193, -1
  %200 = sext i32 %narrow775 to i64
  %smin = call i64 @llvm.smin.i64(i64 %195, i64 1)
  %201 = sub i64 %200, %smin
  %202 = trunc i64 %201 to i32
  %203 = sub i32 %28, %202
  %204 = icmp sgt i32 %203, %28
  %205 = icmp ugt i64 %201, 4294967295
  %206 = or i1 %204, %205
  br i1 %206, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %vector.scevcheck
  %n.vec = and i64 %199, -4
  %ind.end = or i64 %n.vec, 1
  %ind.end639 = sub i64 %195, %n.vec
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.phi = phi <2 x i64> [ zeroinitializer, %vector.ph ], [ %231, %vector.body ]
  %vec.phi641 = phi <2 x i64> [ zeroinitializer, %vector.ph ], [ %232, %vector.body ]
  %vec.phi642 = phi <2 x i64> [ zeroinitializer, %vector.ph ], [ %223, %vector.body ]
  %vec.phi643 = phi <2 x i64> [ zeroinitializer, %vector.ph ], [ %224, %vector.body ]
  %207 = trunc i64 %index to i32
  %208 = getelementptr i32, ptr %.unpack, i64 %index
  %wide.load = load <2 x i32>, ptr %208, align 4, !tbaa !3
  %209 = getelementptr i32, ptr %208, i64 2
  %wide.load645 = load <2 x i32>, ptr %209, align 4, !tbaa !3
  %210 = sub i32 %28, %207
  %211 = sext i32 %210 to i64
  %212 = add nsw i64 %211, -1
  %213 = getelementptr i32, ptr %.unpack, i64 %212
  %214 = getelementptr i32, ptr %213, i64 -1
  %wide.load646 = load <2 x i32>, ptr %214, align 4, !tbaa !3
  %reverse = shufflevector <2 x i32> %wide.load646, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %215 = getelementptr i32, ptr %213, i64 -2
  %216 = getelementptr i32, ptr %215, i64 -1
  %wide.load647 = load <2 x i32>, ptr %216, align 4, !tbaa !3
  %reverse648 = shufflevector <2 x i32> %wide.load647, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %217 = sub <2 x i32> %wide.load, %reverse
  %218 = sub <2 x i32> %wide.load645, %reverse648
  %219 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %217, i1 false)
  %220 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %218, i1 false)
  %221 = sext <2 x i32> %219 to <2 x i64>
  %222 = sext <2 x i32> %220 to <2 x i64>
  %223 = add <2 x i64> %vec.phi642, %221
  %224 = add <2 x i64> %vec.phi643, %222
  %225 = sub <2 x i32> %reverse, %wide.load
  %226 = sub <2 x i32> %reverse648, %wide.load645
  %227 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %225, i1 false)
  %228 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %226, i1 false)
  %229 = sext <2 x i32> %227 to <2 x i64>
  %230 = sext <2 x i32> %228 to <2 x i64>
  %231 = add <2 x i64> %vec.phi, %229
  %232 = add <2 x i64> %vec.phi641, %230
  %index.next = add nuw i64 %index, 4
  %233 = icmp eq i64 %index.next, %n.vec
  br i1 %233, label %middle.block, label %vector.body, !llvm.loop !15

middle.block:                                     ; preds = %vector.body
  %bin.rdx649 = add <2 x i64> %224, %223
  %234 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx649)
  %bin.rdx = add <2 x i64> %232, %231
  %235 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx)
  %cmp.n = icmp eq i64 %199, %n.vec
  br i1 %cmp.n, label %._crit_edge577, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %vector.scevcheck, %.lr.ph576, %middle.block
  %indvars.iv608.ph = phi i64 [ 1, %vector.scevcheck ], [ 1, %.lr.ph576 ], [ %ind.end, %middle.block ]
  %.ph798 = phi i64 [ %195, %vector.scevcheck ], [ %195, %.lr.ph576 ], [ %ind.end639, %middle.block ]
  %.2574.ph = phi i64 [ 0, %vector.scevcheck ], [ 0, %.lr.ph576 ], [ %235, %middle.block ]
  %.2432573.ph = phi i64 [ 0, %vector.scevcheck ], [ 0, %.lr.ph576 ], [ %234, %middle.block ]
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv608 = phi i64 [ %indvars.iv.next609, %scalar.ph ], [ %indvars.iv608.ph, %scalar.ph.preheader ]
  %236 = phi i64 [ %254, %scalar.ph ], [ %.ph798, %scalar.ph.preheader ]
  %.2574 = phi i64 [ %253, %scalar.ph ], [ %.2574.ph, %scalar.ph.preheader ]
  %.2432573 = phi i64 [ %249, %scalar.ph ], [ %.2432573.ph, %scalar.ph.preheader ]
  %237 = add i64 %indvars.iv608, -1
  %238 = getelementptr i32, ptr %.unpack, i64 %237
  %239 = load i32, ptr %238, align 4, !tbaa !3
  %240 = trunc i64 %indvars.iv608 to i32
  %241 = sub i32 %197, %240
  %242 = sext i32 %241 to i64
  %243 = add nsw i64 %242, -1
  %244 = getelementptr i32, ptr %.unpack, i64 %243
  %245 = load i32, ptr %244, align 4, !tbaa !3
  %246 = sub i32 %239, %245
  %247 = call i32 @llvm.abs.i32(i32 %246, i1 false)
  %248 = sext i32 %247 to i64
  %249 = add i64 %.2432573, %248
  %250 = sub i32 %245, %239
  %251 = call i32 @llvm.abs.i32(i32 %250, i1 false)
  %252 = sext i32 %251 to i64
  %253 = add i64 %.2574, %252
  %indvars.iv.next609 = add nuw nsw i64 %indvars.iv608, 1
  %254 = add nsw i64 %236, -1
  %255 = icmp sgt i64 %236, 1
  br i1 %255, label %scalar.ph, label %._crit_edge577, !llvm.loop !16

._crit_edge577:                                   ; preds = %scalar.ph, %middle.block
  %.lcssa637 = phi i64 [ %234, %middle.block ], [ %249, %scalar.ph ]
  %.lcssa636 = phi i64 [ %235, %middle.block ], [ %253, %scalar.ph ]
  %256 = icmp sgt i32 %28, 4
  br i1 %256, label %257, label %.loopexit

257:                                              ; preds = %._crit_edge577
  %258 = lshr i32 %28, 1
  %259 = add nsw i32 %258, -2
  %.not = icmp eq i32 %259, 0
  br i1 %.not, label %.loopexit, label %.lr.ph582

.lr.ph582:                                        ; preds = %257
  %260 = zext i32 %259 to i64
  %261 = add nuw i32 %28, 1
  %min.iters.check660 = icmp ult i32 %259, 12
  br i1 %min.iters.check660, label %scalar.ph659.preheader, label %vector.scevcheck651

vector.scevcheck651:                              ; preds = %.lr.ph582
  %262 = add nsw i64 %260, -1
  %263 = trunc i64 %262 to i32
  %264 = sub i32 %28, %263
  %265 = icmp sgt i32 %264, %28
  %266 = trunc i64 %262 to i32
  %267 = icmp ugt i32 %266, 2147483645
  %268 = icmp ugt i64 %262, 4294967295
  %269 = or i1 %267, %268
  %270 = trunc i64 %262 to i32
  %271 = icmp ugt i32 %270, 2147483646
  %272 = add i32 %28, -1
  %273 = trunc i64 %262 to i32
  %274 = sub i32 %272, %273
  %275 = icmp sgt i32 %274, %272
  %276 = or i1 %265, %269
  %277 = or i1 %271, %276
  %278 = or i1 %275, %277
  br i1 %278, label %scalar.ph659.preheader, label %vector.ph661

vector.ph661:                                     ; preds = %vector.scevcheck651
  %n.vec663 = and i64 %260, 4294967292
  %ind.end664 = and i64 %260, 3
  %.cast = trunc i64 %n.vec663 to i32
  %ind.end666 = or i32 %.cast, 1
  %279 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %.lcssa636, i64 0
  %280 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %.lcssa637, i64 0
  br label %vector.body669

vector.body669:                                   ; preds = %vector.body669, %vector.ph661
  %index670 = phi i64 [ 0, %vector.ph661 ], [ %index.next689, %vector.body669 ]
  %vec.phi671 = phi <2 x i64> [ %279, %vector.ph661 ], [ %316, %vector.body669 ]
  %vec.phi672 = phi <2 x i64> [ zeroinitializer, %vector.ph661 ], [ %317, %vector.body669 ]
  %vec.phi673 = phi <2 x i64> [ %280, %vector.ph661 ], [ %298, %vector.body669 ]
  %vec.phi674 = phi <2 x i64> [ zeroinitializer, %vector.ph661 ], [ %299, %vector.body669 ]
  %.cast675 = trunc i64 %index670 to i32
  %offset.idx676 = or i32 %.cast675, 1
  %281 = sub i32 %261, %offset.idx676
  %282 = sext i32 %281 to i64
  %283 = add nsw i64 %282, -1
  %284 = getelementptr i32, ptr %.unpack, i64 %283
  %285 = getelementptr i32, ptr %284, i64 -1
  %wide.load677 = load <2 x i32>, ptr %285, align 4, !tbaa !3
  %reverse678 = shufflevector <2 x i32> %wide.load677, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %286 = getelementptr i32, ptr %284, i64 -2
  %287 = getelementptr i32, ptr %286, i64 -1
  %wide.load679 = load <2 x i32>, ptr %287, align 4, !tbaa !3
  %reverse680 = shufflevector <2 x i32> %wide.load679, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %288 = shl i64 %index670, 32
  %sext = ashr exact i64 %288, 32
  %289 = or i64 %sext, 1
  %290 = getelementptr i32, ptr %.unpack, i64 %289
  %wide.load681 = load <2 x i32>, ptr %290, align 4, !tbaa !3
  %291 = getelementptr i32, ptr %290, i64 2
  %wide.load682 = load <2 x i32>, ptr %291, align 4, !tbaa !3
  %292 = sub <2 x i32> %reverse678, %wide.load681
  %293 = sub <2 x i32> %reverse680, %wide.load682
  %294 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %292, i1 false)
  %295 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %293, i1 false)
  %296 = sext <2 x i32> %294 to <2 x i64>
  %297 = sext <2 x i32> %295 to <2 x i64>
  %298 = add <2 x i64> %vec.phi673, %296
  %299 = add <2 x i64> %vec.phi674, %297
  %sext777 = shl i64 %index670, 32
  %300 = ashr exact i64 %sext777, 32
  %301 = getelementptr i32, ptr %.unpack, i64 %300
  %wide.load683 = load <2 x i32>, ptr %301, align 4, !tbaa !3
  %302 = getelementptr i32, ptr %301, i64 2
  %wide.load684 = load <2 x i32>, ptr %302, align 4, !tbaa !3
  %303 = sub i32 %28, %offset.idx676
  %304 = sext i32 %303 to i64
  %305 = add nsw i64 %304, -1
  %306 = getelementptr i32, ptr %.unpack, i64 %305
  %307 = getelementptr i32, ptr %306, i64 -1
  %wide.load685 = load <2 x i32>, ptr %307, align 4, !tbaa !3
  %reverse686 = shufflevector <2 x i32> %wide.load685, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %308 = getelementptr i32, ptr %306, i64 -2
  %309 = getelementptr i32, ptr %308, i64 -1
  %wide.load687 = load <2 x i32>, ptr %309, align 4, !tbaa !3
  %reverse688 = shufflevector <2 x i32> %wide.load687, <2 x i32> poison, <2 x i32> <i32 1, i32 0>
  %310 = sub <2 x i32> %wide.load683, %reverse686
  %311 = sub <2 x i32> %wide.load684, %reverse688
  %312 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %310, i1 false)
  %313 = call <2 x i32> @llvm.abs.v2i32(<2 x i32> %311, i1 false)
  %314 = sext <2 x i32> %312 to <2 x i64>
  %315 = sext <2 x i32> %313 to <2 x i64>
  %316 = add <2 x i64> %vec.phi671, %314
  %317 = add <2 x i64> %vec.phi672, %315
  %index.next689 = add nuw i64 %index670, 4
  %318 = icmp eq i64 %index.next689, %n.vec663
  br i1 %318, label %middle.block658, label %vector.body669, !llvm.loop !17

middle.block658:                                  ; preds = %vector.body669
  %bin.rdx692 = add <2 x i64> %299, %298
  %319 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx692)
  %bin.rdx690 = add <2 x i64> %317, %316
  %320 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %bin.rdx690)
  %cmp.n668 = icmp eq i64 %n.vec663, %260
  br i1 %cmp.n668, label %.loopexit, label %scalar.ph659.preheader

scalar.ph659.preheader:                           ; preds = %vector.scevcheck651, %.lr.ph582, %middle.block658
  %.ph790 = phi i64 [ %260, %vector.scevcheck651 ], [ %260, %.lr.ph582 ], [ %ind.end664, %middle.block658 ]
  %.ph791 = phi i32 [ 1, %vector.scevcheck651 ], [ 1, %.lr.ph582 ], [ %ind.end666, %middle.block658 ]
  %.3580.ph = phi i64 [ %.lcssa636, %vector.scevcheck651 ], [ %.lcssa636, %.lr.ph582 ], [ %320, %middle.block658 ]
  %.3433579.ph = phi i64 [ %.lcssa637, %vector.scevcheck651 ], [ %.lcssa637, %.lr.ph582 ], [ %319, %middle.block658 ]
  br label %scalar.ph659

scalar.ph659:                                     ; preds = %scalar.ph659.preheader, %scalar.ph659
  %321 = phi i64 [ %350, %scalar.ph659 ], [ %.ph790, %scalar.ph659.preheader ]
  %322 = phi i32 [ %328, %scalar.ph659 ], [ %.ph791, %scalar.ph659.preheader ]
  %.3580 = phi i64 [ %349, %scalar.ph659 ], [ %.3580.ph, %scalar.ph659.preheader ]
  %.3433579 = phi i64 [ %336, %scalar.ph659 ], [ %.3433579.ph, %scalar.ph659.preheader ]
  %323 = sub i32 %261, %322
  %324 = sext i32 %323 to i64
  %325 = add nsw i64 %324, -1
  %326 = getelementptr i32, ptr %.unpack, i64 %325
  %327 = load i32, ptr %326, align 4, !tbaa !3
  %328 = add i32 %322, 1
  %329 = sext i32 %328 to i64
  %330 = add nsw i64 %329, -1
  %331 = getelementptr i32, ptr %.unpack, i64 %330
  %332 = load i32, ptr %331, align 4, !tbaa !3
  %333 = sub i32 %327, %332
  %334 = call i32 @llvm.abs.i32(i32 %333, i1 false)
  %335 = sext i32 %334 to i64
  %336 = add i64 %.3433579, %335
  %337 = sext i32 %322 to i64
  %338 = add nsw i64 %337, -1
  %339 = getelementptr i32, ptr %.unpack, i64 %338
  %340 = load i32, ptr %339, align 4, !tbaa !3
  %341 = sub i32 %28, %322
  %342 = sext i32 %341 to i64
  %343 = add nsw i64 %342, -1
  %344 = getelementptr i32, ptr %.unpack, i64 %343
  %345 = load i32, ptr %344, align 4, !tbaa !3
  %346 = sub i32 %340, %345
  %347 = call i32 @llvm.abs.i32(i32 %346, i1 false)
  %348 = sext i32 %347 to i64
  %349 = add i64 %.3580, %348
  %350 = add nsw i64 %321, -1
  %351 = icmp ugt i64 %321, 1
  br i1 %351, label %scalar.ph659, label %.loopexit, !llvm.loop !18

.loopexit:                                        ; preds = %scalar.ph659, %middle.block658, %192, %257, %._crit_edge577
  %.4434 = phi i64 [ %.lcssa637, %._crit_edge577 ], [ %.lcssa637, %257 ], [ 0, %192 ], [ %319, %middle.block658 ], [ %336, %scalar.ph659 ]
  %.4 = phi i64 [ %.lcssa636, %._crit_edge577 ], [ %.lcssa636, %257 ], [ 0, %192 ], [ %320, %middle.block658 ], [ %349, %scalar.ph659 ]
  %narrow = add nsw i32 %193, -1
  %352 = sext i32 %narrow to i64
  %353 = getelementptr i32, ptr %.unpack, i64 %352
  %354 = load i32, ptr %353, align 4, !tbaa !3
  %355 = load i32, ptr %.unpack, align 4, !tbaa !3
  %356 = sub i32 %354, %355
  %357 = call i32 @llvm.abs.i32(i32 %356, i1 false)
  %358 = sext i32 %357 to i64
  %359 = add i64 %.4434, %358
  %narrow774 = add nsw i32 %193, 1
  %360 = sext i32 %narrow774 to i64
  %361 = getelementptr i32, ptr %.unpack, i64 %360
  %362 = load i32, ptr %361, align 4, !tbaa !3
  %363 = sext i32 %193 to i64
  %364 = getelementptr i32, ptr %.unpack, i64 %363
  %365 = load i32, ptr %364, align 4, !tbaa !3
  %366 = sub i32 %362, %365
  %367 = call i32 @llvm.abs.i32(i32 %366, i1 false)
  %368 = sext i32 %367 to i64
  %369 = add i64 %359, %368
  %370 = sext i32 %28 to i64
  %371 = add nsw i64 %370, -1
  %372 = getelementptr i32, ptr %.unpack, i64 %371
  %373 = load i32, ptr %372, align 4, !tbaa !3
  %374 = sub i32 %354, %373
  %375 = call i32 @llvm.abs.i32(i32 %374, i1 false)
  %376 = sext i32 %375 to i64
  %377 = add i64 %.4, %376
  %378 = add nsw i64 %195, -1
  %379 = getelementptr i32, ptr %.unpack, i64 %378
  %380 = load i32, ptr %379, align 4, !tbaa !3
  %381 = sub i32 %380, %365
  %382 = call i32 @llvm.abs.i32(i32 %381, i1 false)
  %383 = sext i32 %382 to i64
  %384 = add i64 %377, %383
  %385 = sub i32 %365, %355
  %386 = call i32 @llvm.abs.i32(i32 %385, i1 false)
  %387 = sext i32 %386 to i64
  %388 = sub i32 %362, %354
  %389 = call i32 @llvm.abs.i32(i32 %388, i1 false)
  %390 = sext i32 %389 to i64
  %391 = add i64 %.4434, %390
  %392 = add i64 %391, %387
  %393 = sub i32 %365, %373
  %394 = call i32 @llvm.abs.i32(i32 %393, i1 false)
  %395 = sext i32 %394 to i64
  %396 = add i64 %.4, %395
  %397 = sub i32 %380, %354
  %398 = call i32 @llvm.abs.i32(i32 %397, i1 false)
  %399 = sext i32 %398 to i64
  %400 = add i64 %396, %399
  %401 = call i64 @llvm.smax.i64(i64 %392, i64 %369)
  %402 = call i64 @llvm.smax.i64(i64 %400, i64 %384)
  br label %403

403:                                              ; preds = %._crit_edge596, %.loopexit
  %.5435 = phi i64 [ %183, %._crit_edge596 ], [ %401, %.loopexit ]
  %.5 = phi i64 [ %191, %._crit_edge596 ], [ %402, %.loopexit ]
  %404 = call ptr @_FortranAioBeginExternalFormattedOutput(ptr nonnull @_QQcl.28693029, i64 4, ptr null, i32 -1, ptr nonnull @_QQcl.2f826bb354df98b62ff159f5fe31cff0, i32 49)
  %405 = call i64 @llvm.smax.i64(i64 %.5435, i64 %.5)
  %406 = call i1 @_FortranAioOutputInteger64(ptr %404, i64 %405)
  %407 = call i32 @_FortranAioEndIoStatement(ptr %404)
  %.unpack474 = load ptr, ptr @_QFEa.0, align 8, !tbaa !7
  call void @free(ptr %.unpack474)
  store ptr null, ptr @_QFEa.0, align 8, !tbaa !7
  %408 = call {} @_FortranAStopStatement(i32 0, i1 false, i1 false)
  unreachable
}

; Function Attrs: nofree nosync nounwind memory(readwrite, inaccessiblemem: none)
define void @_QFPmerge_sort(ptr nocapture readonly %0, ptr %1) local_unnamed_addr #3 {
  %3 = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, align 8
  %4 = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, align 8
  %5 = load i32, ptr %0, align 4, !tbaa !3
  %6 = icmp sgt i32 %5, 1
  br i1 %6, label %.lr.ph35, label %._crit_edge36

.lr.ph35:                                         ; preds = %2
  %.fca.1.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 1
  %.fca.2.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 2
  %.fca.3.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 3
  %.fca.4.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 4
  %.fca.5.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 5
  %.fca.6.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, i64 0, i32 6
  %.fca.7.0.0.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %4, 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 %4, 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 %4, i64 0, i32 7, i64 0, i64 2
  %.fca.1.gep13 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 1
  %.fca.2.gep15 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 2
  %.fca.3.gep17 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 3
  %.fca.4.gep19 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 4
  %.fca.5.gep21 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 5
  %.fca.6.gep23 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 6
  %.fca.7.0.0.gep25 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 7, i64 0, i64 0
  %.fca.7.0.1.gep27 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 7, i64 0, i64 1
  %.fca.7.0.2.gep29 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %3, i64 0, i32 7, i64 0, i64 2
  br label %7

7:                                                ; preds = %.lr.ph35, %._crit_edge
  %.033 = phi i32 [ %5, %.lr.ph35 ], [ %42, %._crit_edge ]
  %.03032 = phi i32 [ 1, %.lr.ph35 ], [ %40, %._crit_edge ]
  %.not = icmp ult i32 %.033, 2
  br i1 %.not, label %._crit_edge36, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %7
  %8 = lshr i32 %.033, 1
  %9 = zext i32 %8 to i64
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv = phi i64 [ 1, %.lr.ph.preheader ], [ %indvars.iv.next, %.lr.ph ]
  %10 = phi i64 [ %9, %.lr.ph.preheader ], [ %38, %.lr.ph ]
  %11 = shl nuw i64 %indvars.iv, 1
  %12 = trunc i64 %11 to i32
  %13 = mul i32 %.03032, %12
  %14 = load i32, ptr %0, align 4, !tbaa !3
  %15 = tail call i32 @llvm.smin.i32(i32 %13, i32 %14)
  %16 = trunc i64 %11 to i32
  %17 = add i32 %16, -2
  %18 = mul i32 %17, %.03032
  %19 = or i32 %18, 1
  %20 = sext i32 %19 to i64
  %21 = trunc i64 %11 to i32
  %22 = add i32 %21, -1
  %23 = mul i32 %22, %.03032
  %24 = sext i32 %23 to i64
  %25 = add nsw i64 %20, -1
  %26 = sub nsw i64 %24, %20
  %27 = tail call i64 @llvm.smax.i64(i64 %26, i64 -1)
  %28 = add nsw i64 %27, 1
  %29 = getelementptr i32, ptr %1, i64 %25
  store ptr %29, ptr %4, align 8, !tbaa !7
  store i64 4, ptr %.fca.1.gep, align 8, !tbaa !7
  store i32 20180515, ptr %.fca.2.gep, align 8, !tbaa !7
  store i8 1, ptr %.fca.3.gep, align 4, !tbaa !7
  store i8 9, ptr %.fca.4.gep, align 1, !tbaa !7
  store i8 0, ptr %.fca.5.gep, align 2, !tbaa !7
  store i8 0, ptr %.fca.6.gep, align 1, !tbaa !7
  store i64 1, ptr %.fca.7.0.0.gep, align 8, !tbaa !7
  store i64 %28, ptr %.fca.7.0.1.gep, align 8, !tbaa !7
  store i64 4, ptr %.fca.7.0.2.gep, align 8, !tbaa !7
  %30 = add i32 %23, 1
  %31 = sext i32 %30 to i64
  %32 = sext i32 %15 to i64
  %33 = add nsw i64 %31, -1
  %34 = sub nsw i64 %32, %31
  %35 = tail call i64 @llvm.smax.i64(i64 %34, i64 -1)
  %36 = add nsw i64 %35, 1
  %37 = getelementptr i32, ptr %1, i64 %33
  store ptr %37, ptr %3, align 8, !tbaa !7
  store i64 4, ptr %.fca.1.gep13, align 8, !tbaa !7
  store i32 20180515, ptr %.fca.2.gep15, align 8, !tbaa !7
  store i8 1, ptr %.fca.3.gep17, align 4, !tbaa !7
  store i8 9, ptr %.fca.4.gep19, align 1, !tbaa !7
  store i8 0, ptr %.fca.5.gep21, align 2, !tbaa !7
  store i8 0, ptr %.fca.6.gep23, align 1, !tbaa !7
  store i64 1, ptr %.fca.7.0.0.gep25, align 8, !tbaa !7
  store i64 %36, ptr %.fca.7.0.1.gep27, align 8, !tbaa !7
  store i64 4, ptr %.fca.7.0.2.gep29, align 8, !tbaa !7
  call void @_QFPmerge(ptr nonnull %4, ptr nonnull %3)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %38 = add nsw i64 %10, -1
  %39 = icmp ugt i64 %10, 1
  br i1 %39, label %.lr.ph, label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph
  %40 = shl i32 %.03032, 1
  %41 = add i32 %.033, 1
  %42 = lshr i32 %41, 1
  %43 = icmp sgt i32 %41, 3
  br i1 %43, label %7, label %._crit_edge36

._crit_edge36:                                    ; preds = %7, %._crit_edge, %2
  ret void
}

; Function Attrs: nofree nosync nounwind memory(readwrite, inaccessiblemem: none)
define void @_QFPmerge(ptr nocapture readonly %0, ptr nocapture readonly %1) local_unnamed_addr #3 {
  %3 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %0, i64 0, i32 7, i64 0, i64 1
  %4 = load i64, ptr %3, align 8, !tbaa !7
  %5 = trunc i64 %4 to i32
  %6 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 1
  %7 = load i64, ptr %6, align 8, !tbaa !7
  %8 = trunc i64 %7 to i32
  %9 = add i64 %7, %4
  %sext = shl i64 %9, 32
  %10 = ashr exact i64 %sext, 32
  %11 = tail call i64 @llvm.smax.i64(i64 %10, i64 0)
  %12 = alloca i32, i64 %11, align 4
  %13 = icmp sgt i32 %8, 0
  %14 = icmp sgt i32 %5, 0
  %15 = and i1 %13, %14
  br i1 %15, label %.lr.ph.lr.ph, label %.outer._crit_edge

.lr.ph.lr.ph:                                     ; preds = %2
  %16 = load ptr, ptr %0, align 8, !tbaa !7
  %17 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %0, i64 0, i32 7, i64 0, i64 2
  %18 = load i64, ptr %17, align 8, !tbaa !7
  %19 = load ptr, ptr %1, align 8, !tbaa !7
  %20 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 2
  %21 = load i64, ptr %20, align 8, !tbaa !7
  br label %.lr.ph.split.preheader

.lr.ph.split.preheader:                           ; preds = %.outer, %.lr.ph.lr.ph
  %.0.ph61 = phi i32 [ 1, %.lr.ph.lr.ph ], [ %.041, %.outer ]
  %.027.ph60 = phi i32 [ 1, %.lr.ph.lr.ph ], [ %40, %.outer ]
  %22 = sext i32 %.027.ph60 to i64
  %23 = add nsw i64 %22, -1
  %24 = mul i64 %21, %23
  %25 = getelementptr i8, ptr %19, i64 %24
  %26 = load i32, ptr %25, align 4, !tbaa !3
  %27 = add i32 %.027.ph60, -1
  br label %.lr.ph.split

.lr.ph.split:                                     ; preds = %.lr.ph.split.preheader, %38
  %.041 = phi i32 [ %39, %38 ], [ %.0.ph61, %.lr.ph.split.preheader ]
  %28 = sext i32 %.041 to i64
  %29 = add nsw i64 %28, -1
  %30 = mul i64 %18, %29
  %31 = getelementptr i8, ptr %16, i64 %30
  %32 = load i32, ptr %31, align 4, !tbaa !3
  %33 = icmp slt i32 %32, %26
  %34 = add i32 %27, %.041
  %35 = sext i32 %34 to i64
  %36 = add nsw i64 %35, -1
  %37 = getelementptr i32, ptr %12, i64 %36
  br i1 %33, label %38, label %.outer

38:                                               ; preds = %.lr.ph.split
  store i32 %32, ptr %37, align 4, !tbaa !3
  %39 = add i32 %.041, 1
  %.not = icmp sgt i32 %39, %5
  br i1 %.not, label %.thread, label %.lr.ph.split

.outer:                                           ; preds = %.lr.ph.split
  store i32 %26, ptr %37, align 4, !tbaa !3
  %40 = add i32 %.027.ph60, 1
  %41 = icmp sle i32 %40, %8
  %42 = icmp sle i32 %.041, %5
  %43 = and i1 %41, %42
  br i1 %43, label %.lr.ph.split.preheader, label %.outer._crit_edge

.outer._crit_edge:                                ; preds = %.outer, %2
  %.027.ph.lcssa = phi i32 [ 1, %2 ], [ %40, %.outer ]
  %.0.lcssa = phi i32 [ 1, %2 ], [ %.041, %.outer ]
  %.lcssa37 = phi i1 [ %14, %2 ], [ %42, %.outer ]
  %.lcssa = phi i1 [ %13, %2 ], [ %41, %.outer ]
  br i1 %.lcssa37, label %44, label %68

44:                                               ; preds = %.outer._crit_edge
  %45 = add i32 %.027.ph.lcssa, -1
  %46 = add i32 %45, %.0.lcssa
  %47 = sext i32 %46 to i64
  %48 = sub nsw i64 %10, %47
  %49 = sext i32 %.0.lcssa to i64
  %50 = icmp sgt i64 %48, -1
  br i1 %50, label %.lr.ph69, label %.loopexit

.lr.ph69:                                         ; preds = %44
  %51 = add nuw nsw i64 %48, 1
  %52 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %0, i64 0, i32 7, i64 0, i64 2
  %53 = load i64, ptr %52, align 8, !tbaa !7
  %54 = load ptr, ptr %0, align 8, !tbaa !7
  br label %55

55:                                               ; preds = %.lr.ph69, %55
  %56 = phi i64 [ %51, %.lr.ph69 ], [ %66, %55 ]
  %57 = phi i64 [ 0, %.lr.ph69 ], [ %58, %55 ]
  %58 = add nuw nsw i64 %57, 1
  %59 = add nsw i64 %57, -1
  %60 = add nsw i64 %59, %49
  %61 = mul i64 %53, %60
  %62 = getelementptr i8, ptr %54, i64 %61
  %63 = load i32, ptr %62, align 4, !tbaa !3
  %64 = add nsw i64 %59, %47
  %65 = getelementptr i32, ptr %12, i64 %64
  store i32 %63, ptr %65, align 4, !tbaa !3
  %66 = add nsw i64 %56, -1
  %67 = icmp ugt i64 %56, 1
  br i1 %67, label %55, label %.loopexit

68:                                               ; preds = %.outer._crit_edge
  br i1 %.lcssa, label %.thread, label %.loopexit

.thread:                                          ; preds = %38, %68
  %.027.ph.lcssa97104 = phi i32 [ %.027.ph.lcssa, %68 ], [ %.027.ph60, %38 ]
  %.0.lcssa98103 = phi i32 [ %.0.lcssa, %68 ], [ %39, %38 ]
  %69 = add i32 %.027.ph.lcssa97104, -1
  %70 = add i32 %69, %.0.lcssa98103
  %71 = sext i32 %70 to i64
  %72 = sub nsw i64 %10, %71
  %73 = sext i32 %.027.ph.lcssa97104 to i64
  %74 = icmp sgt i64 %72, -1
  br i1 %74, label %.lr.ph67, label %.loopexit

.lr.ph67:                                         ; preds = %.thread
  %75 = add nuw nsw i64 %72, 1
  %76 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 2
  %77 = load i64, ptr %76, align 8, !tbaa !7
  %78 = load ptr, ptr %1, align 8, !tbaa !7
  br label %79

79:                                               ; preds = %.lr.ph67, %79
  %80 = phi i64 [ %75, %.lr.ph67 ], [ %90, %79 ]
  %81 = phi i64 [ 0, %.lr.ph67 ], [ %82, %79 ]
  %82 = add nuw nsw i64 %81, 1
  %83 = add nsw i64 %81, -1
  %84 = add nsw i64 %83, %73
  %85 = mul i64 %77, %84
  %86 = getelementptr i8, ptr %78, i64 %85
  %87 = load i32, ptr %86, align 4, !tbaa !3
  %88 = add nsw i64 %83, %71
  %89 = getelementptr i32, ptr %12, i64 %88
  store i32 %87, ptr %89, align 4, !tbaa !3
  %90 = add nsw i64 %80, -1
  %91 = icmp ugt i64 %80, 1
  br i1 %91, label %79, label %.loopexit

.loopexit:                                        ; preds = %55, %79, %.thread, %44, %68
  %92 = icmp sgt i64 %4, 0
  br i1 %92, label %.lr.ph71, label %._crit_edge72

.lr.ph71:                                         ; preds = %.loopexit
  %93 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %0, i64 0, i32 7, i64 0, i64 2
  %94 = load i64, ptr %93, align 8, !tbaa !7
  %95 = load ptr, ptr %0, align 8, !tbaa !7
  %xtraiter = and i64 %4, 3
  %96 = icmp ult i64 %4, 4
  br i1 %96, label %._crit_edge72.loopexit.unr-lcssa, label %.lr.ph71.new

.lr.ph71.new:                                     ; preds = %.lr.ph71
  %unroll_iter = and i64 %4, -4
  br label %97

97:                                               ; preds = %97, %.lr.ph71.new
  %98 = phi i64 [ 0, %.lr.ph71.new ], [ %114, %97 ]
  %niter = phi i64 [ 0, %.lr.ph71.new ], [ %niter.next.3, %97 ]
  %99 = or i64 %98, 1
  %100 = getelementptr i32, ptr %12, i64 %98
  %101 = load i32, ptr %100, align 4, !tbaa !3
  %102 = mul i64 %94, %98
  %103 = getelementptr i8, ptr %95, i64 %102
  store i32 %101, ptr %103, align 4, !tbaa !3
  %104 = or i64 %98, 2
  %105 = getelementptr i32, ptr %12, i64 %99
  %106 = load i32, ptr %105, align 4, !tbaa !3
  %107 = mul i64 %94, %99
  %108 = getelementptr i8, ptr %95, i64 %107
  store i32 %106, ptr %108, align 4, !tbaa !3
  %109 = or i64 %98, 3
  %110 = getelementptr i32, ptr %12, i64 %104
  %111 = load i32, ptr %110, align 4, !tbaa !3
  %112 = mul i64 %94, %104
  %113 = getelementptr i8, ptr %95, i64 %112
  store i32 %111, ptr %113, align 4, !tbaa !3
  %114 = add nuw nsw i64 %98, 4
  %115 = getelementptr i32, ptr %12, i64 %109
  %116 = load i32, ptr %115, align 4, !tbaa !3
  %117 = mul i64 %94, %109
  %118 = getelementptr i8, ptr %95, i64 %117
  store i32 %116, ptr %118, align 4, !tbaa !3
  %niter.next.3 = add i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %._crit_edge72.loopexit.unr-lcssa, label %97

._crit_edge72.loopexit.unr-lcssa:                 ; preds = %97, %.lr.ph71
  %.unr = phi i64 [ 0, %.lr.ph71 ], [ %114, %97 ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %._crit_edge72, label %.epil.preheader

.epil.preheader:                                  ; preds = %._crit_edge72.loopexit.unr-lcssa, %.epil.preheader
  %119 = phi i64 [ %120, %.epil.preheader ], [ %.unr, %._crit_edge72.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.epil.preheader ], [ 0, %._crit_edge72.loopexit.unr-lcssa ]
  %120 = add nuw nsw i64 %119, 1
  %121 = getelementptr i32, ptr %12, i64 %119
  %122 = load i32, ptr %121, align 4, !tbaa !3
  %123 = mul i64 %94, %119
  %124 = getelementptr i8, ptr %95, i64 %123
  store i32 %122, ptr %124, align 4, !tbaa !3
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %._crit_edge72, label %.epil.preheader, !llvm.loop !19

._crit_edge72:                                    ; preds = %._crit_edge72.loopexit.unr-lcssa, %.epil.preheader, %.loopexit
  %125 = icmp sgt i64 %7, 0
  br i1 %125, label %.lr.ph74, label %._crit_edge75

.lr.ph74:                                         ; preds = %._crit_edge72
  %126 = shl i64 %4, 32
  %sext34 = add i64 %126, 4294967296
  %127 = ashr exact i64 %sext34, 32
  %128 = add nsw i64 %127, -1
  %129 = getelementptr { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, ptr %1, i64 0, i32 7, i64 0, i64 2
  %130 = load i64, ptr %129, align 8, !tbaa !7
  %131 = load ptr, ptr %1, align 8, !tbaa !7
  %xtraiter129 = and i64 %7, 3
  %132 = icmp ult i64 %7, 4
  br i1 %132, label %._crit_edge75.loopexit.unr-lcssa, label %.lr.ph74.new

.lr.ph74.new:                                     ; preds = %.lr.ph74
  %unroll_iter133 = and i64 %7, -4
  br label %133

133:                                              ; preds = %133, %.lr.ph74.new
  %134 = phi i64 [ 0, %.lr.ph74.new ], [ %153, %133 ]
  %niter134 = phi i64 [ 0, %.lr.ph74.new ], [ %niter134.next.3, %133 ]
  %135 = or i64 %134, 1
  %136 = add i64 %128, %134
  %137 = getelementptr i32, ptr %12, i64 %136
  %138 = load i32, ptr %137, align 4, !tbaa !3
  %139 = mul i64 %130, %134
  %140 = getelementptr i8, ptr %131, i64 %139
  store i32 %138, ptr %140, align 4, !tbaa !3
  %141 = or i64 %134, 2
  %142 = add i64 %127, %134
  %143 = getelementptr i32, ptr %12, i64 %142
  %144 = load i32, ptr %143, align 4, !tbaa !3
  %145 = mul i64 %130, %135
  %146 = getelementptr i8, ptr %131, i64 %145
  store i32 %144, ptr %146, align 4, !tbaa !3
  %147 = or i64 %134, 3
  %148 = add i64 %128, %141
  %149 = getelementptr i32, ptr %12, i64 %148
  %150 = load i32, ptr %149, align 4, !tbaa !3
  %151 = mul i64 %130, %141
  %152 = getelementptr i8, ptr %131, i64 %151
  store i32 %150, ptr %152, align 4, !tbaa !3
  %153 = add nuw nsw i64 %134, 4
  %154 = add i64 %128, %147
  %155 = getelementptr i32, ptr %12, i64 %154
  %156 = load i32, ptr %155, align 4, !tbaa !3
  %157 = mul i64 %130, %147
  %158 = getelementptr i8, ptr %131, i64 %157
  store i32 %156, ptr %158, align 4, !tbaa !3
  %niter134.next.3 = add i64 %niter134, 4
  %niter134.ncmp.3 = icmp eq i64 %niter134.next.3, %unroll_iter133
  br i1 %niter134.ncmp.3, label %._crit_edge75.loopexit.unr-lcssa, label %133

._crit_edge75.loopexit.unr-lcssa:                 ; preds = %133, %.lr.ph74
  %.unr131 = phi i64 [ 0, %.lr.ph74 ], [ %153, %133 ]
  %lcmp.mod132.not = icmp eq i64 %xtraiter129, 0
  br i1 %lcmp.mod132.not, label %._crit_edge75, label %.epil.preheader128

.epil.preheader128:                               ; preds = %._crit_edge75.loopexit.unr-lcssa, %.epil.preheader128
  %159 = phi i64 [ %160, %.epil.preheader128 ], [ %.unr131, %._crit_edge75.loopexit.unr-lcssa ]
  %epil.iter130 = phi i64 [ %epil.iter130.next, %.epil.preheader128 ], [ 0, %._crit_edge75.loopexit.unr-lcssa ]
  %160 = add nuw nsw i64 %159, 1
  %161 = add i64 %128, %159
  %162 = getelementptr i32, ptr %12, i64 %161
  %163 = load i32, ptr %162, align 4, !tbaa !3
  %164 = mul i64 %130, %159
  %165 = getelementptr i8, ptr %131, i64 %164
  store i32 %163, ptr %165, align 4, !tbaa !3
  %epil.iter130.next = add i64 %epil.iter130, 1
  %epil.iter130.cmp.not = icmp eq i64 %epil.iter130.next, %xtraiter129
  br i1 %epil.iter130.cmp.not, label %._crit_edge75, label %.epil.preheader128, !llvm.loop !21

._crit_edge75:                                    ; preds = %._crit_edge75.loopexit.unr-lcssa, %.epil.preheader128, %._crit_edge72
  ret void
}

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
define void @_QFPswap(ptr nocapture %0, ptr nocapture %1) local_unnamed_addr #4 {
  %3 = load i32, ptr %0, align 4, !tbaa !3
  %4 = load i32, ptr %1, align 4, !tbaa !3
  store i32 %4, ptr %0, align 4, !tbaa !3
  store i32 %3, ptr %1, align 4, !tbaa !3
  ret void
}

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

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

declare i32 @_FortranAioEndIoStatement(ptr) local_unnamed_addr

declare ptr @_FortranAioBeginExternalFormattedOutput(ptr, i64, ptr, i32, ptr, i32) local_unnamed_addr

declare i1 @_FortranAioOutputInteger32(ptr, i32) local_unnamed_addr

declare {} @_FortranAStopStatement(i32, i1, i1) local_unnamed_addr

declare i1 @_FortranAioOutputInteger64(ptr, i64) local_unnamed_addr

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.abs.i32(i32, i1 immarg) #5

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i64 @llvm.smin.i64(i64, i64) #5

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x i32> @llvm.abs.v2i32(<2 x i32>, i1 immarg) #5

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

attributes #0 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }
attributes #1 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
attributes #2 = { noreturn }
attributes #3 = { nofree nosync nounwind memory(readwrite, inaccessiblemem: none) }
attributes #4 = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { 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 = !{!"any data access", !5, i64 0}
!5 = !{!"any access", !6, i64 0}
!6 = !{!"Flang Type TBAA Root"}
!7 = !{!8, !8, i64 0}
!8 = !{!"descriptor member", !5, i64 0}
!9 = distinct !{!9, !10, !11}
!10 = !{!"llvm.loop.isvectorized", i32 1}
!11 = !{!"llvm.loop.unroll.runtime.disable"}
!12 = distinct !{!12, !10}
!13 = distinct !{!13, !10, !11}
!14 = distinct !{!14, !10}
!15 = distinct !{!15, !10, !11}
!16 = distinct !{!16, !10}
!17 = distinct !{!17, !10, !11}
!18 = distinct !{!18, !10}
!19 = distinct !{!19, !20}
!20 = !{!"llvm.loop.unroll.disable"}
!21 = distinct !{!21, !20}
