program test
implicit none
character*26 :: s1
character*26 :: s2 = 'abcdefghijklmnopqrstuvwxyz'
integer :: i,max_i=0,num_s1,num_s2

read(*,*) s1 

if(s1 == 'zyxwvutsrqponmlkjihgfedcba') then
  write(*,*) -1
else if (len_trim(s1) < 26) then
  write(*,*) trim(s1)//s2(verify(s2,s1):verify(s2,s1))
else
  do i = 1,25
    if(llt(s1(i:i),s1(i+1:i+1))) then
      max_i = i
    endif
  end do
  
  num_s1 = scan(s2,s1(max_i:max_i))
  num_s2 = scan(s2(num_s1+1:26),s1(max_i+1:26)) + num_s1
  write(*,*) s1(1:max_i-1),s2(num_s2:num_s2)
end if
end program
; 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"

@_QFEmax_i = internal unnamed_addr global i32 0
@_QFEs2 = internal global [26 x i8] c"abcdefghijklmnopqrstuvwxyz"
@_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9 = linkonce constant [73 x i8] c"/home/ubuntu/Downloads/TheStack_IR/Collated/Fortran/Source_6125/source.f\00"
@_QQcl.7A797877767574737271706F6E6D6C6B6A696867666564636261 = linkonce constant [26 x i8] c"zyxwvutsrqponmlkjihgfedcba"
@_QQEnvironmentDefaults = local_unnamed_addr constant ptr null

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

define void @_QQmain() local_unnamed_addr {
  %1 = alloca { ptr, i64, i32, i8, i8, i8, i8 }, align 8
  %2 = alloca { ptr, i64, i32, i8, i8, i8, i8 }, align 8
  %3 = alloca [26 x i8], align 1
  %4 = tail call ptr @_FortranAioBeginExternalListInput(i32 -1, ptr nonnull @_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9, i32 7)
  %5 = call i1 @_FortranAioInputAscii(ptr %4, ptr nonnull %3, i64 26)
  %6 = call i32 @_FortranAioEndIoStatement(ptr %4)
  %7 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %3, ptr nonnull @_QQcl.7A797877767574737271706F6E6D6C6B6A696867666564636261, i64 26, i64 26)
  %8 = icmp eq i32 %7, 0
  br i1 %8, label %9, label %.preheader65

9:                                                ; preds = %0
  %10 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9, i32 10)
  %11 = call i1 @_FortranAioOutputInteger32(ptr %10, i32 -1)
  br label %197

.preheader65:                                     ; preds = %0, %.preheader65
  %12 = phi i64 [ %16, %.preheader65 ], [ 25, %0 ]
  %13 = getelementptr [26 x [1 x i8]], ptr %3, i64 0, i64 %12
  %14 = load i8, ptr %13, align 1, !tbaa !3
  %15 = icmp eq i8 %14, 32
  %16 = add nsw i64 %12, -1
  %17 = icmp ne i64 %12, 0
  %18 = and i1 %15, %17
  br i1 %18, label %.preheader65, label %19

19:                                               ; preds = %.preheader65
  %20 = trunc i64 %12 to i32
  %21 = add i32 %20, 1
  %22 = icmp slt i32 %21, 26
  %23 = select i1 %15, i1 true, i1 %22
  br i1 %23, label %24, label %.preheader

24:                                               ; preds = %19
  %25 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9, i32 12)
  store ptr %3, ptr %1, align 8, !tbaa !7
  %.fca.1.gep16 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 1
  store i64 26, ptr %.fca.1.gep16, align 8, !tbaa !7
  %.fca.2.gep18 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 2
  store i32 20180515, ptr %.fca.2.gep18, align 8, !tbaa !7
  %.fca.3.gep20 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 3
  store i8 0, ptr %.fca.3.gep20, align 4, !tbaa !7
  %.fca.4.gep22 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 4
  store i8 40, ptr %.fca.4.gep22, align 1, !tbaa !7
  %.fca.5.gep24 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 5
  store i8 0, ptr %.fca.5.gep24, align 2, !tbaa !7
  %.fca.6.gep26 = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %1, i64 0, i32 6
  store i8 0, ptr %.fca.6.gep26, align 1, !tbaa !7
  %.fca.1.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 1
  %.fca.2.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 2
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %2, i8 0, i64 16, i1 false)
  store i32 20180515, ptr %.fca.2.gep, align 8, !tbaa !7
  %.fca.3.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 3
  store i8 0, ptr %.fca.3.gep, align 4, !tbaa !7
  %.fca.4.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 4
  store i8 40, ptr %.fca.4.gep, align 1, !tbaa !7
  %.fca.5.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 5
  store i8 2, ptr %.fca.5.gep, align 2, !tbaa !7
  %.fca.6.gep = getelementptr inbounds { ptr, i64, i32, i8, i8, i8, i8 }, ptr %2, i64 0, i32 6
  store i8 0, ptr %.fca.6.gep, align 1, !tbaa !7
  %26 = call {} @_FortranATrim(ptr nonnull %2, ptr nonnull %1, ptr nonnull @_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9, i32 12)
  %.fca.0.load = load ptr, ptr %2, align 8, !tbaa !7
  %.fca.1.load = load i64, ptr %.fca.1.gep, align 8, !tbaa !7
  %27 = call i64 @_FortranAVerify1(ptr nonnull @_QFEs2, i64 26, ptr nonnull %3, i64 26, i1 false)
  %28 = call i64 @_FortranAVerify1(ptr nonnull @_QFEs2, i64 26, ptr nonnull %3, i64 26, i1 false)
  %sext63 = shl i64 %27, 32
  %29 = ashr exact i64 %sext63, 32
  %sext64 = shl i64 %28, 32
  %30 = ashr exact i64 %sext64, 32
  %31 = sub nsw i64 %30, %29
  %32 = call i64 @llvm.smax.i64(i64 %31, i64 -1)
  %33 = add nsw i64 %32, 1
  %34 = add i64 %33, %.fca.1.load
  %35 = alloca i8, i64 %34, align 1
  call void @llvm.memmove.p0.p0.i64(ptr nonnull align 1 %35, ptr align 1 %.fca.0.load, i64 %.fca.1.load, i1 false)
  %36 = icmp sgt i64 %31, -1
  br i1 %36, label %.lr.ph.preheader, label %._crit_edge

.lr.ph.preheader:                                 ; preds = %24
  %37 = add nsw i64 %29, -1
  %38 = getelementptr [26 x [1 x i8]], ptr @_QFEs2, i64 0, i64 %37
  %uglygep = getelementptr i8, ptr %35, i64 %.fca.1.load
  %39 = add nsw i64 %32, 2
  %smin = call i64 @llvm.smin.i64(i64 %33, i64 1)
  %40 = sub nuw nsw i64 %39, %smin
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %uglygep, ptr align 1 %38, i64 %40, i1 false), !tbaa !3
  br label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph.preheader, %24
  %41 = call i1 @_FortranAioOutputAscii(ptr %25, ptr nonnull %35, i64 %34)
  call void @free(ptr %.fca.0.load)
  br label %197

.preheader:                                       ; preds = %19
  %42 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 1
  %43 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %3, ptr nonnull %42, i64 1, i64 1)
  %44 = icmp slt i32 %43, 0
  br i1 %44, label %45, label %.preheader.1

45:                                               ; preds = %.preheader
  store i32 1, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.1

.preheader.1:                                     ; preds = %45, %.preheader
  %46 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 1
  %47 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 2
  %48 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %46, ptr nonnull %47, i64 1, i64 1)
  %49 = icmp slt i32 %48, 0
  br i1 %49, label %50, label %.preheader.2

50:                                               ; preds = %.preheader.1
  store i32 2, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.2

.preheader.2:                                     ; preds = %50, %.preheader.1
  %51 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 2
  %52 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 3
  %53 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %51, ptr nonnull %52, i64 1, i64 1)
  %54 = icmp slt i32 %53, 0
  br i1 %54, label %55, label %.preheader.3

55:                                               ; preds = %.preheader.2
  store i32 3, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.3

.preheader.3:                                     ; preds = %55, %.preheader.2
  %56 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 3
  %57 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 4
  %58 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %56, ptr nonnull %57, i64 1, i64 1)
  %59 = icmp slt i32 %58, 0
  br i1 %59, label %60, label %.preheader.4

60:                                               ; preds = %.preheader.3
  store i32 4, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.4

.preheader.4:                                     ; preds = %60, %.preheader.3
  %61 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 4
  %62 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 5
  %63 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %61, ptr nonnull %62, i64 1, i64 1)
  %64 = icmp slt i32 %63, 0
  br i1 %64, label %65, label %.preheader.5

65:                                               ; preds = %.preheader.4
  store i32 5, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.5

.preheader.5:                                     ; preds = %65, %.preheader.4
  %66 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 5
  %67 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 6
  %68 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %66, ptr nonnull %67, i64 1, i64 1)
  %69 = icmp slt i32 %68, 0
  br i1 %69, label %70, label %.preheader.6

70:                                               ; preds = %.preheader.5
  store i32 6, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.6

.preheader.6:                                     ; preds = %70, %.preheader.5
  %71 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 6
  %72 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 7
  %73 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %71, ptr nonnull %72, i64 1, i64 1)
  %74 = icmp slt i32 %73, 0
  br i1 %74, label %75, label %.preheader.7

75:                                               ; preds = %.preheader.6
  store i32 7, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.7

.preheader.7:                                     ; preds = %75, %.preheader.6
  %76 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 7
  %77 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 8
  %78 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %76, ptr nonnull %77, i64 1, i64 1)
  %79 = icmp slt i32 %78, 0
  br i1 %79, label %80, label %.preheader.8

80:                                               ; preds = %.preheader.7
  store i32 8, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.8

.preheader.8:                                     ; preds = %80, %.preheader.7
  %81 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 8
  %82 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 9
  %83 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %81, ptr nonnull %82, i64 1, i64 1)
  %84 = icmp slt i32 %83, 0
  br i1 %84, label %85, label %.preheader.9

85:                                               ; preds = %.preheader.8
  store i32 9, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.9

.preheader.9:                                     ; preds = %85, %.preheader.8
  %86 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 9
  %87 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 10
  %88 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %86, ptr nonnull %87, i64 1, i64 1)
  %89 = icmp slt i32 %88, 0
  br i1 %89, label %90, label %.preheader.10

90:                                               ; preds = %.preheader.9
  store i32 10, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.10

.preheader.10:                                    ; preds = %90, %.preheader.9
  %91 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 10
  %92 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 11
  %93 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %91, ptr nonnull %92, i64 1, i64 1)
  %94 = icmp slt i32 %93, 0
  br i1 %94, label %95, label %.preheader.11

95:                                               ; preds = %.preheader.10
  store i32 11, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.11

.preheader.11:                                    ; preds = %95, %.preheader.10
  %96 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 11
  %97 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 12
  %98 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %96, ptr nonnull %97, i64 1, i64 1)
  %99 = icmp slt i32 %98, 0
  br i1 %99, label %100, label %.preheader.12

100:                                              ; preds = %.preheader.11
  store i32 12, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.12

.preheader.12:                                    ; preds = %100, %.preheader.11
  %101 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 12
  %102 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 13
  %103 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %101, ptr nonnull %102, i64 1, i64 1)
  %104 = icmp slt i32 %103, 0
  br i1 %104, label %105, label %.preheader.13

105:                                              ; preds = %.preheader.12
  store i32 13, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.13

.preheader.13:                                    ; preds = %105, %.preheader.12
  %106 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 13
  %107 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 14
  %108 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %106, ptr nonnull %107, i64 1, i64 1)
  %109 = icmp slt i32 %108, 0
  br i1 %109, label %110, label %.preheader.14

110:                                              ; preds = %.preheader.13
  store i32 14, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.14

.preheader.14:                                    ; preds = %110, %.preheader.13
  %111 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 14
  %112 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 15
  %113 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %111, ptr nonnull %112, i64 1, i64 1)
  %114 = icmp slt i32 %113, 0
  br i1 %114, label %115, label %.preheader.15

115:                                              ; preds = %.preheader.14
  store i32 15, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.15

.preheader.15:                                    ; preds = %115, %.preheader.14
  %116 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 15
  %117 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 16
  %118 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %116, ptr nonnull %117, i64 1, i64 1)
  %119 = icmp slt i32 %118, 0
  br i1 %119, label %120, label %.preheader.16

120:                                              ; preds = %.preheader.15
  store i32 16, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.16

.preheader.16:                                    ; preds = %120, %.preheader.15
  %121 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 16
  %122 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 17
  %123 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %121, ptr nonnull %122, i64 1, i64 1)
  %124 = icmp slt i32 %123, 0
  br i1 %124, label %125, label %.preheader.17

125:                                              ; preds = %.preheader.16
  store i32 17, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.17

.preheader.17:                                    ; preds = %125, %.preheader.16
  %126 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 17
  %127 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 18
  %128 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %126, ptr nonnull %127, i64 1, i64 1)
  %129 = icmp slt i32 %128, 0
  br i1 %129, label %130, label %.preheader.18

130:                                              ; preds = %.preheader.17
  store i32 18, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.18

.preheader.18:                                    ; preds = %130, %.preheader.17
  %131 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 18
  %132 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 19
  %133 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %131, ptr nonnull %132, i64 1, i64 1)
  %134 = icmp slt i32 %133, 0
  br i1 %134, label %135, label %.preheader.19

135:                                              ; preds = %.preheader.18
  store i32 19, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.19

.preheader.19:                                    ; preds = %135, %.preheader.18
  %136 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 19
  %137 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 20
  %138 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %136, ptr nonnull %137, i64 1, i64 1)
  %139 = icmp slt i32 %138, 0
  br i1 %139, label %140, label %.preheader.20

140:                                              ; preds = %.preheader.19
  store i32 20, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.20

.preheader.20:                                    ; preds = %140, %.preheader.19
  %141 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 20
  %142 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 21
  %143 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %141, ptr nonnull %142, i64 1, i64 1)
  %144 = icmp slt i32 %143, 0
  br i1 %144, label %145, label %.preheader.21

145:                                              ; preds = %.preheader.20
  store i32 21, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.21

.preheader.21:                                    ; preds = %145, %.preheader.20
  %146 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 21
  %147 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 22
  %148 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %146, ptr nonnull %147, i64 1, i64 1)
  %149 = icmp slt i32 %148, 0
  br i1 %149, label %150, label %.preheader.22

150:                                              ; preds = %.preheader.21
  store i32 22, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.22

.preheader.22:                                    ; preds = %150, %.preheader.21
  %151 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 22
  %152 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 23
  %153 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %151, ptr nonnull %152, i64 1, i64 1)
  %154 = icmp slt i32 %153, 0
  br i1 %154, label %155, label %.preheader.23

155:                                              ; preds = %.preheader.22
  store i32 23, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.23

.preheader.23:                                    ; preds = %155, %.preheader.22
  %156 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 23
  %157 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 24
  %158 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %156, ptr nonnull %157, i64 1, i64 1)
  %159 = icmp slt i32 %158, 0
  br i1 %159, label %160, label %.preheader.24

160:                                              ; preds = %.preheader.23
  store i32 24, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %.preheader.24

.preheader.24:                                    ; preds = %160, %.preheader.23
  %161 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 24
  %162 = getelementptr inbounds [26 x [1 x i8]], ptr %3, i64 0, i64 25
  %163 = call i32 @_FortranACharacterCompareScalar1(ptr nonnull %161, ptr nonnull %162, i64 1, i64 1)
  %164 = icmp slt i32 %163, 0
  br i1 %164, label %165, label %166

165:                                              ; preds = %.preheader.24
  store i32 25, ptr @_QFEmax_i, align 4, !tbaa !3
  br label %166

166:                                              ; preds = %165, %.preheader.24
  %167 = load i32, ptr @_QFEmax_i, align 4, !tbaa !3
  %168 = sext i32 %167 to i64
  %169 = add nsw i64 %168, -1
  %170 = getelementptr [26 x [1 x i8]], ptr %3, i64 0, i64 %169
  %171 = call i64 @_FortranAScan1(ptr nonnull @_QFEs2, i64 26, ptr %170, i64 1, i1 false)
  %172 = shl i64 %171, 32
  %sext = add i64 %172, 4294967296
  %173 = ashr exact i64 %sext, 32
  %174 = add nsw i64 %173, -1
  %175 = getelementptr [26 x [1 x i8]], ptr @_QFEs2, i64 0, i64 %174
  %176 = sub nsw i64 27, %173
  %177 = call i64 @llvm.smax.i64(i64 %176, i64 0)
  %178 = load i32, ptr @_QFEmax_i, align 4, !tbaa !3
  %179 = add i32 %178, 1
  %180 = sext i32 %179 to i64
  %181 = add nsw i64 %180, -1
  %182 = getelementptr [26 x [1 x i8]], ptr %3, i64 0, i64 %181
  %183 = sub nsw i64 27, %180
  %184 = call i64 @llvm.smax.i64(i64 %183, i64 0)
  %185 = call i64 @_FortranAScan1(ptr %175, i64 %177, ptr %182, i64 %184, i1 false)
  %186 = add i64 %185, %171
  %187 = call ptr @_FortranAioBeginExternalListOutput(i32 -1, ptr nonnull @_QQcl.12648fb4cf8f039830bfc3a8c9cb57c9, i32 22)
  %188 = load i32, ptr @_QFEmax_i, align 4, !tbaa !3
  %189 = add i32 %188, -1
  %190 = call i32 @llvm.smax.i32(i32 %189, i32 0)
  %191 = zext i32 %190 to i64
  %192 = call i1 @_FortranAioOutputAscii(ptr %187, ptr nonnull %3, i64 %191)
  %sext62 = shl i64 %186, 32
  %193 = ashr exact i64 %sext62, 32
  %194 = add nsw i64 %193, -1
  %195 = getelementptr [26 x [1 x i8]], ptr @_QFEs2, i64 0, i64 %194
  %196 = call i1 @_FortranAioOutputAscii(ptr %187, ptr %195, i64 1)
  br label %197

197:                                              ; preds = %9, %._crit_edge, %166
  %.sink = phi ptr [ %10, %9 ], [ %25, %._crit_edge ], [ %187, %166 ]
  %198 = call i32 @_FortranAioEndIoStatement(ptr %.sink)
  ret void
}

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

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

declare i32 @_FortranAioEndIoStatement(ptr) local_unnamed_addr

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

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

declare i1 @_FortranAioOutputInteger32(ptr, i32) local_unnamed_addr

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

declare {} @_FortranATrim(ptr, ptr, ptr, i32) local_unnamed_addr

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

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #1

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

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

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

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4

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

!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}
